rostests/winetests/gdiplus/image.c

   1 /*
   2  * Unit test suite for images
   3  *
   4  * Copyright (C) 2007 Google (Evan Stade)
   5  * Copyright (C) 2012 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 #define COBJMACROS
  23
  24 #include <math.h>
  25 #include <assert.h>
  26 #include <stdio.h>
  27
  28 #include <initguid.h>
  29 #define WIN32_NO_STATUS
  30 #define _INC_WINDOWS
  31 #define COM_NO_WINDOWS_H
  32
  33 //#include "windows.h"
  34 #include <wine/test.h>
  35 #include <wingdi.h>
  36 #include <winnls.h>
  37 #include <ole2.h>
  38 #include <gdiplus.h>
  39
  40 #define expect(expected, got) ok((got) == (expected), "Expected %d, got %d\n", (UINT)(expected), (UINT)(got))
  41 #define expectf(expected, got) ok(fabs((expected) - (got)) < 0.0001, "Expected %f, got %f\n", (expected), (got))
  42
  43 static BOOL color_match(ARGB c1, ARGB c2, BYTE max_diff)
  44 {
  45     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
  46     c1 >>= 8; c2 >>= 8;
  47     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
  48     c1 >>= 8; c2 >>= 8;
  49     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
  50     c1 >>= 8; c2 >>= 8;
  51     if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
  52     return TRUE;
  53 }
  54
  55 static void expect_guid(REFGUID expected, REFGUID got, int line, BOOL todo)
  56 {
  57     WCHAR bufferW[39];
  58     char buffer[39];
  59     char buffer2[39];
  60
  61     StringFromGUID2(got, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
  62     WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
  63     StringFromGUID2(expected, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
  64     WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer2, sizeof(buffer2), NULL, NULL);
  65     if(todo)
  66         todo_wine ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
  67     else
  68         ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
  69 }
  70
  71 static void expect_rawformat(REFGUID expected, GpImage *img, int line, BOOL todo)
  72 {
  73     GUID raw;
  74     GpStatus stat;
  75
  76     stat = GdipGetImageRawFormat(img, &raw);
  77     ok_(__FILE__, line)(stat == Ok, "GdipGetImageRawFormat failed with %d\n", stat);
  78     if(stat != Ok) return;
  79     expect_guid(expected, &raw, line, todo);
  80 }
  81
  82 static void test_bufferrawformat(void* buff, int size, REFGUID expected, int line, BOOL todo)
  83 {
  84     LPSTREAM stream;
  85     HGLOBAL  hglob;
  86     LPBYTE   data;
  87     HRESULT  hres;
  88     GpStatus stat;
  89     GpImage *img;
  90
  91     hglob = GlobalAlloc (0, size);
  92     data = GlobalLock (hglob);
  93     memcpy(data, buff, size);
  94     GlobalUnlock(hglob); data = NULL;
  95
  96     hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
  97     ok_(__FILE__, line)(hres == S_OK, "Failed to create a stream\n");
  98     if(hres != S_OK) return;
  99
 100     stat = GdipLoadImageFromStream(stream, &img);
 101     ok_(__FILE__, line)(stat == Ok, "Failed to create a Bitmap\n");
 102     if(stat != Ok){
 103         IStream_Release(stream);
 104         return;
 105     }
 106
 107     expect_rawformat(expected, img, line, todo);
 108
 109     GdipDisposeImage(img);
 110     IStream_Release(stream);
 111 }
 112
 113 static void test_Scan0(void)
 114 {
 115     GpBitmap *bm;
 116     GpStatus stat;
 117     BYTE buff[360];
 118
 119     bm = NULL;
 120     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
 121     expect(Ok, stat);
 122     ok(NULL != bm, "Expected bitmap to be initialized\n");
 123     if (stat == Ok)
 124         GdipDisposeImage((GpImage*)bm);
 125
 126     bm = (GpBitmap*)0xdeadbeef;
 127     stat = GdipCreateBitmapFromScan0(10, -10, 10, PixelFormat24bppRGB, NULL, &bm);
 128     expect(InvalidParameter, stat);
 129     ok( !bm, "expected null bitmap\n" );
 130
 131     bm = (GpBitmap*)0xdeadbeef;
 132     stat = GdipCreateBitmapFromScan0(-10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
 133     expect(InvalidParameter, stat);
 134     ok( !bm, "expected null bitmap\n" );
 135
 136     bm = (GpBitmap*)0xdeadbeef;
 137     stat = GdipCreateBitmapFromScan0(10, 0, 10, PixelFormat24bppRGB, NULL, &bm);
 138     expect(InvalidParameter, stat);
 139     ok( !bm, "expected null bitmap\n" );
 140
 141     bm = NULL;
 142     stat = GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB, buff, &bm);
 143     expect(Ok, stat);
 144     ok(NULL != bm, "Expected bitmap to be initialized\n");
 145     if (stat == Ok)
 146         GdipDisposeImage((GpImage*)bm);
 147
 148     bm = (GpBitmap*) 0xdeadbeef;
 149     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, buff, &bm);
 150     expect(InvalidParameter, stat);
 151     ok( !bm, "expected null bitmap\n" );
 152
 153     bm = (GpBitmap*)0xdeadbeef;
 154     stat = GdipCreateBitmapFromScan0(10, 10, 0, PixelFormat24bppRGB, buff, &bm);
 155     expect(InvalidParameter, stat);
 156     ok( bm == (GpBitmap*)0xdeadbeef, "expected deadbeef bitmap\n" );
 157
 158     bm = NULL;
 159     stat = GdipCreateBitmapFromScan0(10, 10, -8, PixelFormat24bppRGB, buff, &bm);
 160     expect(Ok, stat);
 161     ok(NULL != bm, "Expected bitmap to be initialized\n");
 162     if (stat == Ok)
 163         GdipDisposeImage((GpImage*)bm);
 164
 165     bm = (GpBitmap*)0xdeadbeef;
 166     stat = GdipCreateBitmapFromScan0(10, 10, -10, PixelFormat24bppRGB, buff, &bm);
 167     expect(InvalidParameter, stat);
 168     ok( !bm, "expected null bitmap\n" );
 169 }
 170
 171 static void test_FromGdiDib(void)
 172 {
 173     GpBitmap *bm;
 174     GpStatus stat;
 175     BYTE buff[400];
 176     BYTE rbmi[sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)];
 177     BITMAPINFO *bmi = (BITMAPINFO*)rbmi;
 178     PixelFormat format;
 179
 180     bm = NULL;
 181
 182     memset(rbmi, 0, sizeof(rbmi));
 183
 184     bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 185     bmi->bmiHeader.biWidth = 10;
 186     bmi->bmiHeader.biHeight = 10;
 187     bmi->bmiHeader.biPlanes = 1;
 188     bmi->bmiHeader.biBitCount = 32;
 189     bmi->bmiHeader.biCompression = BI_RGB;
 190
 191     stat = GdipCreateBitmapFromGdiDib(NULL, buff, &bm);
 192     expect(InvalidParameter, stat);
 193
 194     stat = GdipCreateBitmapFromGdiDib(bmi, NULL, &bm);
 195     expect(InvalidParameter, stat);
 196
 197     stat = GdipCreateBitmapFromGdiDib(bmi, buff, NULL);
 198     expect(InvalidParameter, stat);
 199
 200     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 201     expect(Ok, stat);
 202     ok(NULL != bm, "Expected bitmap to be initialized\n");
 203     if (stat == Ok)
 204     {
 205         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 206         expect(Ok, stat);
 207         expect(PixelFormat32bppRGB, format);
 208
 209         GdipDisposeImage((GpImage*)bm);
 210     }
 211
 212     bmi->bmiHeader.biBitCount = 24;
 213     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 214     expect(Ok, stat);
 215     ok(NULL != bm, "Expected bitmap to be initialized\n");
 216     if (stat == Ok)
 217     {
 218         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 219         expect(Ok, stat);
 220         expect(PixelFormat24bppRGB, format);
 221
 222         GdipDisposeImage((GpImage*)bm);
 223     }
 224
 225     bmi->bmiHeader.biBitCount = 16;
 226     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 227     expect(Ok, stat);
 228     ok(NULL != bm, "Expected bitmap to be initialized\n");
 229     if (stat == Ok)
 230     {
 231         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 232         expect(Ok, stat);
 233         expect(PixelFormat16bppRGB555, format);
 234
 235         GdipDisposeImage((GpImage*)bm);
 236     }
 237
 238     bmi->bmiHeader.biBitCount = 8;
 239     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 240     expect(Ok, stat);
 241     ok(NULL != bm, "Expected bitmap to be initialized\n");
 242     if (stat == Ok)
 243     {
 244         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 245         expect(Ok, stat);
 246         expect(PixelFormat8bppIndexed, format);
 247
 248         GdipDisposeImage((GpImage*)bm);
 249     }
 250
 251     bmi->bmiHeader.biBitCount = 4;
 252     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 253     expect(Ok, stat);
 254     ok(NULL != bm, "Expected bitmap to be initialized\n");
 255     if (stat == Ok)
 256     {
 257         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 258         expect(Ok, stat);
 259         expect(PixelFormat4bppIndexed, format);
 260
 261         GdipDisposeImage((GpImage*)bm);
 262     }
 263
 264     bmi->bmiHeader.biBitCount = 1;
 265     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 266     expect(Ok, stat);
 267     ok(NULL != bm, "Expected bitmap to be initialized\n");
 268     if (stat == Ok)
 269     {
 270         stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
 271         expect(Ok, stat);
 272         expect(PixelFormat1bppIndexed, format);
 273
 274         GdipDisposeImage((GpImage*)bm);
 275     }
 276
 277     bmi->bmiHeader.biBitCount = 0;
 278     stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
 279     expect(InvalidParameter, stat);
 280 }
 281
 282 static void test_GetImageDimension(void)
 283 {
 284     GpBitmap *bm;
 285     GpStatus stat;
 286     const REAL WIDTH = 10.0, HEIGHT = 20.0;
 287     REAL w,h;
 288
 289     bm = (GpBitmap*)0xdeadbeef;
 290     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
 291     expect(Ok,stat);
 292     ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
 293     ok(NULL != bm, "Expected bitmap to not be NULL\n");
 294
 295     stat = GdipGetImageDimension(NULL,&w,&h);
 296     expect(InvalidParameter, stat);
 297
 298     stat = GdipGetImageDimension((GpImage*)bm,NULL,&h);
 299     expect(InvalidParameter, stat);
 300
 301     stat = GdipGetImageDimension((GpImage*)bm,&w,NULL);
 302     expect(InvalidParameter, stat);
 303
 304     w = -1;
 305     h = -1;
 306     stat = GdipGetImageDimension((GpImage*)bm,&w,&h);
 307     expect(Ok, stat);
 308     expectf(WIDTH,  w);
 309     expectf(HEIGHT, h);
 310     GdipDisposeImage((GpImage*)bm);
 311 }
 312
 313 static void test_GdipImageGetFrameDimensionsCount(void)
 314 {
 315     GpBitmap *bm;
 316     GpStatus stat;
 317     const REAL WIDTH = 10.0, HEIGHT = 20.0;
 318     UINT w;
 319     GUID dimension = {0};
 320     UINT count;
 321     ARGB color;
 322
 323     bm = (GpBitmap*)0xdeadbeef;
 324     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
 325     expect(Ok,stat);
 326     ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
 327     ok(NULL != bm, "Expected bitmap to not be NULL\n");
 328
 329     stat = GdipImageGetFrameDimensionsCount(NULL,&w);
 330     expect(InvalidParameter, stat);
 331
 332     stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,NULL);
 333     expect(InvalidParameter, stat);
 334
 335     w = -1;
 336     stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,&w);
 337     expect(Ok, stat);
 338     expect(1, w);
 339
 340     stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 1);
 341     expect(Ok, stat);
 342     expect_guid(&FrameDimensionPage, &dimension, __LINE__, FALSE);
 343
 344     stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 2);
 345     expect(InvalidParameter, stat);
 346
 347     stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 0);
 348     expect(InvalidParameter, stat);
 349
 350     stat = GdipImageGetFrameCount(NULL, &dimension, &count);
 351     expect(InvalidParameter, stat);
 352
 353     /* WinXP crashes on this test */
 354     if(0)
 355     {
 356         stat = GdipImageGetFrameCount((GpImage*)bm, &dimension, NULL);
 357         expect(InvalidParameter, stat);
 358     }
 359
 360     stat = GdipImageGetFrameCount((GpImage*)bm, NULL, &count);
 361     expect(Ok, stat);
 362
 363     count = 12345;
 364     stat = GdipImageGetFrameCount((GpImage*)bm, &dimension, &count);
 365     expect(Ok, stat);
 366     expect(1, count);
 367
 368     GdipBitmapSetPixel(bm, 0, 0, 0xffffffff);
 369
 370     stat = GdipImageSelectActiveFrame((GpImage*)bm, &dimension, 0);
 371     expect(Ok, stat);
 372
 373     /* SelectActiveFrame has no effect on image data of memory bitmaps */
 374     color = 0xdeadbeef;
 375     GdipBitmapGetPixel(bm, 0, 0, &color);
 376     expect(0xffffffff, color);
 377
 378     GdipDisposeImage((GpImage*)bm);
 379 }
 380
 381 static void test_LoadingImages(void)
 382 {
 383     GpStatus stat;
 384     GpBitmap *bm;
 385     GpImage *img;
 386     static const WCHAR nonexistentW[] = {'n','o','n','e','x','i','s','t','e','n','t',0};
 387
 388     stat = GdipCreateBitmapFromFile(0, 0);
 389     expect(InvalidParameter, stat);
 390
 391     bm = (GpBitmap *)0xdeadbeef;
 392     stat = GdipCreateBitmapFromFile(0, &bm);
 393     expect(InvalidParameter, stat);
 394     ok(bm == (GpBitmap *)0xdeadbeef, "returned %p\n", bm);
 395
 396     bm = (GpBitmap *)0xdeadbeef;
 397     stat = GdipCreateBitmapFromFile(nonexistentW, &bm);
 398     todo_wine expect(InvalidParameter, stat);
 399     ok(!bm, "returned %p\n", bm);
 400
 401     stat = GdipLoadImageFromFile(0, 0);
 402     expect(InvalidParameter, stat);
 403
 404     img = (GpImage *)0xdeadbeef;
 405     stat = GdipLoadImageFromFile(0, &img);
 406     expect(InvalidParameter, stat);
 407     ok(img == (GpImage *)0xdeadbeef, "returned %p\n", img);
 408
 409     img = (GpImage *)0xdeadbeef;
 410     stat = GdipLoadImageFromFile(nonexistentW, &img);
 411     todo_wine expect(OutOfMemory, stat);
 412     ok(!img, "returned %p\n", img);
 413
 414     stat = GdipLoadImageFromFileICM(0, 0);
 415     expect(InvalidParameter, stat);
 416
 417     img = (GpImage *)0xdeadbeef;
 418     stat = GdipLoadImageFromFileICM(0, &img);
 419     expect(InvalidParameter, stat);
 420     ok(img == (GpImage *)0xdeadbeef, "returned %p\n", img);
 421
 422     img = (GpImage *)0xdeadbeef;
 423     stat = GdipLoadImageFromFileICM(nonexistentW, &img);
 424     todo_wine expect(OutOfMemory, stat);
 425     ok(!img, "returned %p\n", img);
 426 }
 427
 428 static void test_SavingImages(void)
 429 {
 430     GpStatus stat;
 431     GpBitmap *bm;
 432     UINT n;
 433     UINT s;
 434     const REAL WIDTH = 10.0, HEIGHT = 20.0;
 435     REAL w, h;
 436     ImageCodecInfo *codecs;
 437     static const CHAR filenameA[] = "a.bmp";
 438     static const WCHAR filename[] = { 'a','.','b','m','p',0 };
 439
 440     codecs = NULL;
 441
 442     stat = GdipSaveImageToFile(0, 0, 0, 0);
 443     expect(InvalidParameter, stat);
 444
 445     bm = NULL;
 446     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 447     expect(Ok, stat);
 448     if (!bm)
 449         return;
 450
 451     /* invalid params */
 452     stat = GdipSaveImageToFile((GpImage*)bm, 0, 0, 0);
 453     expect(InvalidParameter, stat);
 454
 455     stat = GdipSaveImageToFile((GpImage*)bm, filename, 0, 0);
 456     expect(InvalidParameter, stat);
 457
 458     /* encoder tests should succeed -- already tested */
 459     stat = GdipGetImageEncodersSize(&n, &s);
 460     if (stat != Ok || n == 0) goto cleanup;
 461
 462     codecs = GdipAlloc(s);
 463     if (!codecs) goto cleanup;
 464
 465     stat = GdipGetImageEncoders(n, s, codecs);
 466     if (stat != Ok) goto cleanup;
 467
 468     stat = GdipSaveImageToFile((GpImage*)bm, filename, &codecs[0].Clsid, 0);
 469     expect(Ok, stat);
 470
 471     GdipDisposeImage((GpImage*)bm);
 472     bm = 0;
 473
 474     /* re-load and check image stats */
 475     stat = GdipLoadImageFromFile(filename, (GpImage**)&bm);
 476     expect(Ok, stat);
 477     if (stat != Ok) goto cleanup;
 478
 479     stat = GdipGetImageDimension((GpImage*)bm, &w, &h);
 480     if (stat != Ok) goto cleanup;
 481
 482     expectf(WIDTH, w);
 483     expectf(HEIGHT, h);
 484
 485  cleanup:
 486     GdipFree(codecs);
 487     if (bm)
 488         GdipDisposeImage((GpImage*)bm);
 489     ok(DeleteFileA(filenameA), "Delete failed.\n");
 490 }
 491
 492 static void test_encoders(void)
 493 {
 494     GpStatus stat;
 495     UINT n;
 496     UINT s;
 497     ImageCodecInfo *codecs;
 498     int i;
 499     int bmp_found;
 500
 501     static const CHAR bmp_format[] = "BMP";
 502
 503     stat = GdipGetImageEncodersSize(&n, &s);
 504     expect(stat, Ok);
 505
 506     codecs = GdipAlloc(s);
 507     if (!codecs)
 508         return;
 509
 510     stat = GdipGetImageEncoders(n, s, NULL);
 511     expect(GenericError, stat);
 512
 513     stat = GdipGetImageEncoders(0, s, codecs);
 514     expect(GenericError, stat);
 515
 516     stat = GdipGetImageEncoders(n, s-1, codecs);
 517     expect(GenericError, stat);
 518
 519     stat = GdipGetImageEncoders(n, s+1, codecs);
 520     expect(GenericError, stat);
 521
 522     stat = GdipGetImageEncoders(n, s, codecs);
 523     expect(stat, Ok);
 524
 525     bmp_found = FALSE;
 526     for (i = 0; i < n; i++)
 527         {
 528             CHAR desc[32];
 529
 530             WideCharToMultiByte(CP_ACP, 0, codecs[i].FormatDescription, -1,
 531                                 desc, 32, 0, 0);
 532
 533             if (CompareStringA(LOCALE_SYSTEM_DEFAULT, 0,
 534                                desc, -1,
 535                                bmp_format, -1) == CSTR_EQUAL) {
 536                 bmp_found = TRUE;
 537                 break;
 538             }
 539         }
 540     if (!bmp_found)
 541         ok(FALSE, "No BMP codec found.\n");
 542
 543     GdipFree(codecs);
 544 }
 545
 546 static void test_LockBits(void)
 547 {
 548     GpStatus stat;
 549     GpBitmap *bm;
 550     GpRect rect;
 551     BitmapData bd;
 552     const INT WIDTH = 10, HEIGHT = 20;
 553     ARGB color;
 554     int y;
 555
 556     bm = NULL;
 557     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 558     expect(Ok, stat);
 559
 560     rect.X = 2;
 561     rect.Y = 3;
 562     rect.Width = 4;
 563     rect.Height = 5;
 564
 565     stat = GdipBitmapSetPixel(bm, 2, 3, 0xffc30000);
 566     expect(Ok, stat);
 567
 568     stat = GdipBitmapSetPixel(bm, 2, 8, 0xff480000);
 569     expect(Ok, stat);
 570
 571     /* read-only */
 572     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 573     expect(Ok, stat);
 574
 575     if (stat == Ok) {
 576         expect(0xc3, ((BYTE*)bd.Scan0)[2]);
 577         expect(0x48, ((BYTE*)bd.Scan0)[2 + bd.Stride * 5]);
 578
 579         ((char*)bd.Scan0)[2] = 0xff;
 580
 581         stat = GdipBitmapUnlockBits(bm, &bd);
 582         expect(Ok, stat);
 583     }
 584
 585     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 586     expect(Ok, stat);
 587     expect(0xffff0000, color);
 588
 589     stat = GdipBitmapSetPixel(bm, 2, 3, 0xffc30000);
 590     expect(Ok, stat);
 591
 592     /* read-only, with NULL rect -> whole bitmap lock */
 593     stat = GdipBitmapLockBits(bm, NULL, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 594     expect(Ok, stat);
 595     expect(bd.Width,  WIDTH);
 596     expect(bd.Height, HEIGHT);
 597
 598     if (stat == Ok) {
 599         ((char*)bd.Scan0)[2 + 2*3 + 3*bd.Stride] = 0xff;
 600
 601         stat = GdipBitmapUnlockBits(bm, &bd);
 602         expect(Ok, stat);
 603     }
 604
 605     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 606     expect(Ok, stat);
 607     expect(0xffff0000, color);
 608
 609     /* read-only, consecutive */
 610     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 611     expect(Ok, stat);
 612
 613     if (stat == Ok) {
 614         stat = GdipBitmapUnlockBits(bm, &bd);
 615         expect(Ok, stat);
 616     }
 617
 618     stat = GdipDisposeImage((GpImage*)bm);
 619     expect(Ok, stat);
 620     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 621     expect(Ok, stat);
 622
 623     /* read x2 */
 624     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 625     expect(Ok, stat);
 626     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 627     expect(WrongState, stat);
 628
 629     stat = GdipBitmapUnlockBits(bm, &bd);
 630     expect(Ok, stat);
 631
 632     stat = GdipDisposeImage((GpImage*)bm);
 633     expect(Ok, stat);
 634     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 635     expect(Ok, stat);
 636
 637     stat = GdipBitmapSetPixel(bm, 2, 3, 0xffff0000);
 638     expect(Ok, stat);
 639
 640     stat = GdipBitmapSetPixel(bm, 2, 8, 0xffc30000);
 641     expect(Ok, stat);
 642
 643     /* write, no conversion */
 644     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
 645     expect(Ok, stat);
 646
 647     if (stat == Ok) {
 648         /* all bits are readable, inside the rect or not */
 649         expect(0xff, ((BYTE*)bd.Scan0)[2]);
 650         expect(0xc3, ((BYTE*)bd.Scan0)[2 + bd.Stride * 5]);
 651
 652         stat = GdipBitmapUnlockBits(bm, &bd);
 653         expect(Ok, stat);
 654     }
 655
 656     /* read, conversion */
 657     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat32bppARGB, &bd);
 658     expect(Ok, stat);
 659
 660     if (stat == Ok) {
 661         expect(0xff, ((BYTE*)bd.Scan0)[2]);
 662         if (0)
 663             /* Areas outside the rectangle appear to be uninitialized */
 664             ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
 665
 666         ((BYTE*)bd.Scan0)[2] = 0xc3;
 667
 668         stat = GdipBitmapUnlockBits(bm, &bd);
 669         expect(Ok, stat);
 670     }
 671
 672     /* writes do not work in read mode if there was a conversion */
 673     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 674     expect(Ok, stat);
 675     expect(0xffff0000, color);
 676
 677     /* read/write, conversion */
 678     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeWrite, PixelFormat32bppARGB, &bd);
 679     expect(Ok, stat);
 680
 681     if (stat == Ok) {
 682         expect(0xff, ((BYTE*)bd.Scan0)[2]);
 683         ((BYTE*)bd.Scan0)[1] = 0x88;
 684         if (0)
 685             /* Areas outside the rectangle appear to be uninitialized */
 686             ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
 687
 688         stat = GdipBitmapUnlockBits(bm, &bd);
 689         expect(Ok, stat);
 690     }
 691
 692     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 693     expect(Ok, stat);
 694     expect(0xffff8800, color);
 695
 696     /* write, conversion */
 697     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &bd);
 698     expect(Ok, stat);
 699
 700     if (stat == Ok) {
 701         if (0)
 702         {
 703             /* This is completely uninitialized. */
 704             ok(0xff != ((BYTE*)bd.Scan0)[2], "original image bits are readable\n");
 705             ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
 706         }
 707
 708         /* Initialize the buffer so the unlock doesn't access undefined memory */
 709         for (y=0; y<5; y++)
 710             memset(((BYTE*)bd.Scan0) + bd.Stride * y, 0, 12);
 711
 712         ((BYTE*)bd.Scan0)[0] = 0x12;
 713         ((BYTE*)bd.Scan0)[1] = 0x34;
 714         ((BYTE*)bd.Scan0)[2] = 0x56;
 715
 716         stat = GdipBitmapUnlockBits(bm, &bd);
 717         expect(Ok, stat);
 718     }
 719
 720     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 721     expect(Ok, stat);
 722     expect(0xff563412, color);
 723
 724     stat = GdipBitmapGetPixel(bm, 2, 8, &color);
 725     expect(Ok, stat);
 726     expect(0xffc30000, color);
 727
 728     stat = GdipDisposeImage((GpImage*)bm);
 729     expect(Ok, stat);
 730     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 731     expect(Ok, stat);
 732
 733     /* write, no modification */
 734     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
 735     expect(Ok, stat);
 736
 737     if (stat == Ok) {
 738         stat = GdipBitmapUnlockBits(bm, &bd);
 739         expect(Ok, stat);
 740     }
 741
 742     /* write, consecutive */
 743     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
 744     expect(Ok, stat);
 745
 746     if (stat == Ok) {
 747         stat = GdipBitmapUnlockBits(bm, &bd);
 748         expect(Ok, stat);
 749     }
 750
 751     stat = GdipDisposeImage((GpImage*)bm);
 752     expect(Ok, stat);
 753     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 754     expect(Ok, stat);
 755
 756     /* write, modify */
 757     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
 758     expect(Ok, stat);
 759
 760     if (stat == Ok) {
 761         if (bd.Scan0)
 762             ((char*)bd.Scan0)[2] = 0xff;
 763
 764         stat = GdipBitmapUnlockBits(bm, &bd);
 765         expect(Ok, stat);
 766     }
 767
 768     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 769     expect(Ok, stat);
 770     expect(0xffff0000, color);
 771
 772     stat = GdipDisposeImage((GpImage*)bm);
 773     expect(Ok, stat);
 774
 775     /* dispose locked */
 776     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
 777     expect(Ok, stat);
 778     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
 779     expect(Ok, stat);
 780     stat = GdipDisposeImage((GpImage*)bm);
 781     expect(Ok, stat);
 782 }
 783
 784 static void test_LockBits_UserBuf(void)
 785 {
 786     GpStatus stat;
 787     GpBitmap *bm;
 788     GpRect rect;
 789     BitmapData bd;
 790     const INT WIDTH = 10, HEIGHT = 20;
 791     DWORD bits[200];
 792     ARGB color;
 793
 794     bm = NULL;
 795     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat32bppARGB, NULL, &bm);
 796     expect(Ok, stat);
 797
 798     memset(bits, 0xaa, sizeof(bits));
 799
 800     rect.X = 2;
 801     rect.Y = 3;
 802     rect.Width = 4;
 803     rect.Height = 5;
 804
 805     bd.Width = 4;
 806     bd.Height = 6;
 807     bd.Stride = WIDTH * 4;
 808     bd.PixelFormat = PixelFormat32bppARGB;
 809     bd.Scan0 = &bits[2+3*WIDTH];
 810     bd.Reserved = 0xaaaaaaaa;
 811
 812     /* read-only */
 813     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
 814     expect(Ok, stat);
 815
 816     expect(0xaaaaaaaa, bits[0]);
 817     expect(0, bits[2+3*WIDTH]);
 818
 819     bits[2+3*WIDTH] = 0xdeadbeef;
 820
 821     if (stat == Ok) {
 822         stat = GdipBitmapUnlockBits(bm, &bd);
 823         expect(Ok, stat);
 824     }
 825
 826     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 827     expect(Ok, stat);
 828     expect(0, color);
 829
 830     /* write-only */
 831     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
 832     expect(Ok, stat);
 833
 834     expect(0xdeadbeef, bits[2+3*WIDTH]);
 835     bits[2+3*WIDTH] = 0x12345678;
 836
 837     if (stat == Ok) {
 838         stat = GdipBitmapUnlockBits(bm, &bd);
 839         expect(Ok, stat);
 840     }
 841
 842     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 843     expect(Ok, stat);
 844     expect(0x12345678, color);
 845
 846     bits[2+3*WIDTH] = 0;
 847
 848     /* read/write */
 849     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeWrite|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
 850     expect(Ok, stat);
 851
 852     expect(0x12345678, bits[2+3*WIDTH]);
 853     bits[2+3*WIDTH] = 0xdeadbeef;
 854
 855     if (stat == Ok) {
 856         stat = GdipBitmapUnlockBits(bm, &bd);
 857         expect(Ok, stat);
 858     }
 859
 860     stat = GdipBitmapGetPixel(bm, 2, 3, &color);
 861     expect(Ok, stat);
 862     expect(0xdeadbeef, color);
 863
 864     stat = GdipDisposeImage((GpImage*)bm);
 865     expect(Ok, stat);
 866 }
 867
 868 struct BITMAPINFOWITHBITFIELDS
 869 {
 870     BITMAPINFOHEADER bmiHeader;
 871     DWORD masks[3];
 872 };
 873
 874 union BITMAPINFOUNION
 875 {
 876     BITMAPINFO bi;
 877     struct BITMAPINFOWITHBITFIELDS bf;
 878 };
 879
 880 static void test_GdipCreateBitmapFromHBITMAP(void)
 881 {
 882     GpBitmap* gpbm = NULL;
 883     HBITMAP hbm = NULL;
 884     HPALETTE hpal = NULL;
 885     GpStatus stat;
 886     BYTE buff[1000];
 887     LOGPALETTE* LogPal = NULL;
 888     REAL width, height;
 889     const REAL WIDTH1 = 5;
 890     const REAL HEIGHT1 = 15;
 891     const REAL WIDTH2 = 10;
 892     const REAL HEIGHT2 = 20;
 893     HDC hdc;
 894     union BITMAPINFOUNION bmi;
 895     BYTE *bits;
 896     PixelFormat format;
 897
 898     stat = GdipCreateBitmapFromHBITMAP(NULL, NULL, NULL);
 899     expect(InvalidParameter, stat);
 900
 901     hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
 902     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, NULL);
 903     expect(InvalidParameter, stat);
 904
 905     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
 906     expect(Ok, stat);
 907     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
 908     expectf(WIDTH1,  width);
 909     expectf(HEIGHT1, height);
 910     if (stat == Ok)
 911         GdipDisposeImage((GpImage*)gpbm);
 912     DeleteObject(hbm);
 913
 914     memset(buff, 0, sizeof(buff));
 915     hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
 916     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
 917     expect(Ok, stat);
 918     /* raw format */
 919     expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)gpbm, __LINE__, FALSE);
 920
 921     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
 922     expectf(WIDTH2,  width);
 923     expectf(HEIGHT2, height);
 924     if (stat == Ok)
 925         GdipDisposeImage((GpImage*)gpbm);
 926     DeleteObject(hbm);
 927
 928     hdc = CreateCompatibleDC(0);
 929     ok(hdc != NULL, "CreateCompatibleDC failed\n");
 930     bmi.bi.bmiHeader.biSize = sizeof(bmi.bi.bmiHeader);
 931     bmi.bi.bmiHeader.biHeight = HEIGHT1;
 932     bmi.bi.bmiHeader.biWidth = WIDTH1;
 933     bmi.bi.bmiHeader.biBitCount = 24;
 934     bmi.bi.bmiHeader.biPlanes = 1;
 935     bmi.bi.bmiHeader.biCompression = BI_RGB;
 936     bmi.bi.bmiHeader.biClrUsed = 0;
 937
 938     hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 939     ok(hbm != NULL, "CreateDIBSection failed\n");
 940
 941     bits[0] = 0;
 942
 943     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
 944     expect(Ok, stat);
 945     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
 946     expectf(WIDTH1,  width);
 947     expectf(HEIGHT1, height);
 948     if (stat == Ok)
 949     {
 950         /* test whether writing to the bitmap affects the original */
 951         stat = GdipBitmapSetPixel(gpbm, 0, 0, 0xffffffff);
 952         expect(Ok, stat);
 953
 954         expect(0, bits[0]);
 955
 956         GdipDisposeImage((GpImage*)gpbm);
 957     }
 958
 959     LogPal = GdipAlloc(sizeof(LOGPALETTE));
 960     ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
 961     LogPal->palVersion = 0x300;
 962     LogPal->palNumEntries = 1;
 963     hpal = CreatePalette(LogPal);
 964     ok(hpal != NULL, "CreatePalette failed\n");
 965     GdipFree(LogPal);
 966
 967     stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
 968     expect(Ok, stat);
 969
 970     if (stat == Ok)
 971         GdipDisposeImage((GpImage*)gpbm);
 972
 973     DeleteObject(hpal);
 974     DeleteObject(hbm);
 975
 976     /* 16-bit 555 dib, rgb */
 977     bmi.bi.bmiHeader.biBitCount = 16;
 978     bmi.bi.bmiHeader.biCompression = BI_RGB;
 979
 980     hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 981     ok(hbm != NULL, "CreateDIBSection failed\n");
 982
 983     bits[0] = 0;
 984
 985     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
 986     expect(Ok, stat);
 987
 988     if (stat == Ok)
 989     {
 990         stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
 991         expect(Ok, stat);
 992         expectf(WIDTH1,  width);
 993         expectf(HEIGHT1, height);
 994
 995         stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
 996         expect(Ok, stat);
 997         expect(PixelFormat16bppRGB555, format);
 998
 999         GdipDisposeImage((GpImage*)gpbm);
1000     }
1001     DeleteObject(hbm);
1002
1003     /* 16-bit 555 dib, with bitfields */
1004     bmi.bi.bmiHeader.biSize = sizeof(bmi);
1005     bmi.bi.bmiHeader.biCompression = BI_BITFIELDS;
1006     bmi.bf.masks[0] = 0x7c00;
1007     bmi.bf.masks[1] = 0x3e0;
1008     bmi.bf.masks[2] = 0x1f;
1009
1010     hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1011     ok(hbm != NULL, "CreateDIBSection failed\n");
1012
1013     bits[0] = 0;
1014
1015     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
1016     expect(Ok, stat);
1017
1018     if (stat == Ok)
1019     {
1020         stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
1021         expect(Ok, stat);
1022         expectf(WIDTH1,  width);
1023         expectf(HEIGHT1, height);
1024
1025         stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
1026         expect(Ok, stat);
1027         expect(PixelFormat16bppRGB555, format);
1028
1029         GdipDisposeImage((GpImage*)gpbm);
1030     }
1031     DeleteObject(hbm);
1032
1033     /* 16-bit 565 dib, with bitfields */
1034     bmi.bf.masks[0] = 0xf800;
1035     bmi.bf.masks[1] = 0x7e0;
1036     bmi.bf.masks[2] = 0x1f;
1037
1038     hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1039     ok(hbm != NULL, "CreateDIBSection failed\n");
1040
1041     bits[0] = 0;
1042
1043     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
1044     expect(Ok, stat);
1045
1046     if (stat == Ok)
1047     {
1048         stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
1049         expect(Ok, stat);
1050         expectf(WIDTH1,  width);
1051         expectf(HEIGHT1, height);
1052
1053         stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
1054         expect(Ok, stat);
1055         expect(PixelFormat16bppRGB565, format);
1056
1057         GdipDisposeImage((GpImage*)gpbm);
1058     }
1059     DeleteObject(hbm);
1060
1061     DeleteDC(hdc);
1062 }
1063
1064 static void test_GdipGetImageFlags(void)
1065 {
1066     GpImage *img;
1067     GpStatus stat;
1068     UINT flags;
1069
1070     img = (GpImage*)0xdeadbeef;
1071
1072     stat = GdipGetImageFlags(NULL, NULL);
1073     expect(InvalidParameter, stat);
1074
1075     stat = GdipGetImageFlags(NULL, &flags);
1076     expect(InvalidParameter, stat);
1077
1078     stat = GdipGetImageFlags(img, NULL);
1079     expect(InvalidParameter, stat);
1080
1081     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat1bppIndexed, NULL, (GpBitmap**)&img);
1082     expect(Ok, stat);
1083     stat = GdipGetImageFlags(img, &flags);
1084     expect(Ok, stat);
1085     expect(ImageFlagsHasAlpha, flags);
1086     GdipDisposeImage(img);
1087
1088     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat4bppIndexed, NULL, (GpBitmap**)&img);
1089     expect(Ok, stat);
1090     stat = GdipGetImageFlags(img, &flags);
1091     expect(Ok, stat);
1092     expect(ImageFlagsHasAlpha, flags);
1093     GdipDisposeImage(img);
1094
1095     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat8bppIndexed, NULL, (GpBitmap**)&img);
1096     expect(Ok, stat);
1097     stat = GdipGetImageFlags(img, &flags);
1098     expect(Ok, stat);
1099     expect(ImageFlagsHasAlpha, flags);
1100     GdipDisposeImage(img);
1101
1102     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppGrayScale, NULL, (GpBitmap**)&img);
1103     expect(Ok, stat);
1104     stat = GdipGetImageFlags(img, &flags);
1105     expect(Ok, stat);
1106     expect(ImageFlagsNone, flags);
1107     GdipDisposeImage(img);
1108
1109     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB555, NULL, (GpBitmap**)&img);
1110     expect(Ok, stat);
1111     stat = GdipGetImageFlags(img, &flags);
1112     expect(Ok, stat);
1113     expect(ImageFlagsNone, flags);
1114     GdipDisposeImage(img);
1115
1116     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB565, NULL, (GpBitmap**)&img);
1117     expect(Ok, stat);
1118     stat = GdipGetImageFlags(img, &flags);
1119     expect(Ok, stat);
1120     expect(ImageFlagsNone, flags);
1121     GdipDisposeImage(img);
1122
1123     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppARGB1555, NULL, (GpBitmap**)&img);
1124     expect(Ok, stat);
1125     stat = GdipGetImageFlags(img, &flags);
1126     expect(Ok, stat);
1127     expect(ImageFlagsHasAlpha, flags);
1128     GdipDisposeImage(img);
1129
1130     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, (GpBitmap**)&img);
1131     expect(Ok, stat);
1132     stat = GdipGetImageFlags(img, &flags);
1133     expect(Ok, stat);
1134     expect(ImageFlagsNone, flags);
1135     GdipDisposeImage(img);
1136
1137     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppRGB, NULL, (GpBitmap**)&img);
1138     expect(Ok, stat);
1139     stat = GdipGetImageFlags(img, &flags);
1140     expect(Ok, stat);
1141     expect(ImageFlagsNone, flags);
1142     GdipDisposeImage(img);
1143
1144     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppARGB, NULL, (GpBitmap**)&img);
1145     expect(Ok, stat);
1146     stat = GdipGetImageFlags(img, &flags);
1147     expect(Ok, stat);
1148     expect(ImageFlagsHasAlpha, flags);
1149     GdipDisposeImage(img);
1150
1151     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppPARGB, NULL, (GpBitmap**)&img);
1152     expect(Ok, stat);
1153     stat = GdipGetImageFlags(img, &flags);
1154     expect(Ok, stat);
1155     expect(ImageFlagsHasAlpha, flags);
1156     GdipDisposeImage(img);
1157
1158     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat48bppRGB, NULL, (GpBitmap**)&img);
1159     expect(Ok, stat);
1160     if (stat == Ok)
1161     {
1162         stat = GdipGetImageFlags(img, &flags);
1163         expect(Ok, stat);
1164         expect(ImageFlagsNone, flags);
1165         GdipDisposeImage(img);
1166     }
1167
1168     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppARGB, NULL, (GpBitmap**)&img);
1169     expect(Ok, stat);
1170     if (stat == Ok)
1171     {
1172         expect(Ok, stat);
1173         stat = GdipGetImageFlags(img, &flags);
1174         expect(Ok, stat);
1175         expect(ImageFlagsHasAlpha, flags);
1176         GdipDisposeImage(img);
1177     }
1178
1179     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppPARGB, NULL, (GpBitmap**)&img);
1180     expect(Ok, stat);
1181     if (stat == Ok)
1182     {
1183         expect(Ok, stat);
1184         stat = GdipGetImageFlags(img, &flags);
1185         expect(Ok, stat);
1186         expect(ImageFlagsHasAlpha, flags);
1187         GdipDisposeImage(img);
1188     }
1189 }
1190
1191 static void test_GdipCloneImage(void)
1192 {
1193     GpStatus stat;
1194     GpRectF rectF;
1195     GpUnit unit;
1196     GpBitmap *bm;
1197     GpImage *image_src, *image_dest = NULL;
1198     const INT WIDTH = 10, HEIGHT = 20;
1199
1200     /* Create an image, clone it, delete the original, make sure the copy works */
1201     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
1202     expect(Ok, stat);
1203     expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bm, __LINE__, FALSE);
1204
1205     image_src = ((GpImage*)bm);
1206     stat = GdipCloneImage(image_src, &image_dest);
1207     expect(Ok, stat);
1208     expect_rawformat(&ImageFormatMemoryBMP, image_dest, __LINE__, FALSE);
1209
1210     stat = GdipDisposeImage((GpImage*)bm);
1211     expect(Ok, stat);
1212     stat = GdipGetImageBounds(image_dest, &rectF, &unit);
1213     expect(Ok, stat);
1214
1215     /* Treat FP values carefully */
1216     expectf((REAL)WIDTH, rectF.Width);
1217     expectf((REAL)HEIGHT, rectF.Height);
1218
1219     stat = GdipDisposeImage(image_dest);
1220     expect(Ok, stat);
1221 }
1222
1223 static void test_testcontrol(void)
1224 {
1225     GpStatus stat;
1226     DWORD param;
1227
1228     param = 0;
1229     stat = GdipTestControl(TestControlGetBuildNumber, &param);
1230     expect(Ok, stat);
1231     ok(param != 0, "Build number expected, got %u\n", param);
1232 }
1233
1234 static void test_fromhicon(void)
1235 {
1236     static const BYTE bmp_bits[1024];
1237     HBITMAP hbmMask, hbmColor;
1238     ICONINFO info;
1239     HICON hIcon;
1240     GpStatus stat;
1241     GpBitmap *bitmap = NULL;
1242     UINT dim;
1243     ImageType type;
1244     PixelFormat format;
1245
1246     /* NULL */
1247     stat = GdipCreateBitmapFromHICON(NULL, NULL);
1248     expect(InvalidParameter, stat);
1249     stat = GdipCreateBitmapFromHICON(NULL, &bitmap);
1250     expect(InvalidParameter, stat);
1251
1252     /* color icon 1 bit */
1253     hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
1254     ok(hbmMask != 0, "CreateBitmap failed\n");
1255     hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
1256     ok(hbmColor != 0, "CreateBitmap failed\n");
1257     info.fIcon = TRUE;
1258     info.xHotspot = 8;
1259     info.yHotspot = 8;
1260     info.hbmMask = hbmMask;
1261     info.hbmColor = hbmColor;
1262     hIcon = CreateIconIndirect(&info);
1263     ok(hIcon != 0, "CreateIconIndirect failed\n");
1264     DeleteObject(hbmMask);
1265     DeleteObject(hbmColor);
1266
1267     stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
1268     ok(stat == Ok ||
1269        broken(stat == InvalidParameter), /* Win98 */
1270        "Expected Ok, got %.8x\n", stat);
1271     if(stat == Ok){
1272        /* check attributes */
1273        stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
1274        expect(Ok, stat);
1275        expect(16, dim);
1276        stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
1277        expect(Ok, stat);
1278        expect(16, dim);
1279        stat = GdipGetImageType((GpImage*)bitmap, &type);
1280        expect(Ok, stat);
1281        expect(ImageTypeBitmap, type);
1282        stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
1283        expect(Ok, stat);
1284        expect(PixelFormat32bppARGB, format);
1285        /* raw format */
1286        expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1287        GdipDisposeImage((GpImage*)bitmap);
1288     }
1289     DestroyIcon(hIcon);
1290
1291     /* color icon 8 bpp */
1292     hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
1293     ok(hbmMask != 0, "CreateBitmap failed\n");
1294     hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
1295     ok(hbmColor != 0, "CreateBitmap failed\n");
1296     info.fIcon = TRUE;
1297     info.xHotspot = 8;
1298     info.yHotspot = 8;
1299     info.hbmMask = hbmMask;
1300     info.hbmColor = hbmColor;
1301     hIcon = CreateIconIndirect(&info);
1302     ok(hIcon != 0, "CreateIconIndirect failed\n");
1303     DeleteObject(hbmMask);
1304     DeleteObject(hbmColor);
1305
1306     stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
1307     expect(Ok, stat);
1308     if(stat == Ok){
1309         /* check attributes */
1310         stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
1311         expect(Ok, stat);
1312         expect(16, dim);
1313         stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
1314         expect(Ok, stat);
1315         expect(16, dim);
1316         stat = GdipGetImageType((GpImage*)bitmap, &type);
1317         expect(Ok, stat);
1318         expect(ImageTypeBitmap, type);
1319         stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
1320         expect(Ok, stat);
1321         expect(PixelFormat32bppARGB, format);
1322         /* raw format */
1323         expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1324         GdipDisposeImage((GpImage*)bitmap);
1325     }
1326     DestroyIcon(hIcon);
1327 }
1328
1329 /* 1x1 pixel png */
1330 static const unsigned char pngimage[285] = {
1331 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
1332 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
1333 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
1334 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
1335 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
1336 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
1337 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
1338 };
1339 /* 1x1 pixel gif */
1340 static const unsigned char gifimage[35] = {
1341 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
1342 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
1343 0x01,0x00,0x3b
1344 };
1345 /* 1x1 pixel bmp */
1346 static const unsigned char bmpimage[66] = {
1347 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
1348 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
1349 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
1350 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
1351 0x00,0x00
1352 };
1353 /* 1x1 pixel jpg */
1354 static const unsigned char jpgimage[285] = {
1355 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
1356 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
1357 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
1358 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
1359 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
1360 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
1361 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
1362 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1363 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1364 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
1365 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
1366 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1367 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
1368 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
1369 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1370 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
1371 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
1372 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
1373 };
1374 /* 1x1 pixel tiff */
1375 static const unsigned char tiffimage[] = {
1376 0x49,0x49,0x2a,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0xfe,0x00,
1377 0x04,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x00,0x01,0x00,
1378 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1379 0x00,0x00,0x02,0x01,0x03,0x00,0x03,0x00,0x00,0x00,0xd2,0x00,0x00,0x00,0x03,0x01,
1380 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x01,0x03,0x00,0x01,0x00,
1381 0x00,0x00,0x02,0x00,0x00,0x00,0x0d,0x01,0x02,0x00,0x1b,0x00,0x00,0x00,0xd8,0x00,
1382 0x00,0x00,0x11,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x12,0x01,
1383 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x01,0x03,0x00,0x01,0x00,
1384 0x00,0x00,0x03,0x00,0x00,0x00,0x16,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x40,0x00,
1385 0x00,0x00,0x17,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x1a,0x01,
1386 0x05,0x00,0x01,0x00,0x00,0x00,0xf4,0x00,0x00,0x00,0x1b,0x01,0x05,0x00,0x01,0x00,
1387 0x00,0x00,0xfc,0x00,0x00,0x00,0x1c,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1388 0x00,0x00,0x28,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
1389 0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x2f,0x68,0x6f,0x6d,0x65,0x2f,0x6d,0x65,
1390 0x68,0x2f,0x44,0x65,0x73,0x6b,0x74,0x6f,0x70,0x2f,0x74,0x65,0x73,0x74,0x2e,0x74,
1391 0x69,0x66,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x48,
1392 0x00,0x00,0x00,0x01
1393 };
1394 /* 320x320 twip wmf */
1395 static const unsigned char wmfimage[180] = {
1396 0xd7,0xcd,0xc6,0x9a,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0x40,0x01,0xa0,0x05,
1397 0x00,0x00,0x00,0x00,0xb1,0x52,0x01,0x00,0x09,0x00,0x00,0x03,0x4f,0x00,0x00,0x00,
1398 0x0f,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0b,0x02,0x00,0x00,
1399 0x00,0x00,0x05,0x00,0x00,0x00,0x0c,0x02,0x40,0x01,0x40,0x01,0x04,0x00,0x00,0x00,
1400 0x02,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x04,0x01,0x0d,0x00,0x08,0x00,0x00,0x00,
1401 0xfa,0x02,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
1402 0x2d,0x01,0x00,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,0x01,0x00,0x00,0x00,0x00,0x00,
1403 0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x01,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,
1404 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x02,0x00,
1405 0x07,0x00,0x00,0x00,0x1b,0x04,0x40,0x01,0x40,0x01,0x00,0x00,0x00,0x00,0x04,0x00,
1406 0x00,0x00,0xf0,0x01,0x00,0x00,0x04,0x00,0x00,0x00,0xf0,0x01,0x01,0x00,0x03,0x00,
1407 0x00,0x00,0x00,0x00
1408 };
1409 static void test_getrawformat(void)
1410 {
1411     test_bufferrawformat((void*)pngimage, sizeof(pngimage), &ImageFormatPNG,  __LINE__, FALSE);
1412     test_bufferrawformat((void*)gifimage, sizeof(gifimage), &ImageFormatGIF,  __LINE__, FALSE);
1413     test_bufferrawformat((void*)bmpimage, sizeof(bmpimage), &ImageFormatBMP,  __LINE__, FALSE);
1414     test_bufferrawformat((void*)jpgimage, sizeof(jpgimage), &ImageFormatJPEG, __LINE__, FALSE);
1415     test_bufferrawformat((void*)tiffimage, sizeof(tiffimage), &ImageFormatTIFF, __LINE__, FALSE);
1416     test_bufferrawformat((void*)wmfimage, sizeof(wmfimage), &ImageFormatWMF, __LINE__, FALSE);
1417 }
1418
1419 static void test_loadwmf(void)
1420 {
1421     LPSTREAM stream;
1422     HGLOBAL  hglob;
1423     LPBYTE   data;
1424     HRESULT  hres;
1425     GpStatus stat;
1426     GpImage *img;
1427     GpRectF bounds;
1428     GpUnit unit;
1429     REAL res = 12345.0;
1430     MetafileHeader header;
1431
1432     hglob = GlobalAlloc (0, sizeof(wmfimage));
1433     data = GlobalLock (hglob);
1434     memcpy(data, wmfimage, sizeof(wmfimage));
1435     GlobalUnlock(hglob); data = NULL;
1436
1437     hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
1438     ok(hres == S_OK, "Failed to create a stream\n");
1439     if(hres != S_OK) return;
1440
1441     stat = GdipLoadImageFromStream(stream, &img);
1442     ok(stat == Ok, "Failed to create a Bitmap\n");
1443     if(stat != Ok){
1444         IStream_Release(stream);
1445         return;
1446     }
1447
1448     IStream_Release(stream);
1449
1450     stat = GdipGetImageBounds(img, &bounds, &unit);
1451     expect(Ok, stat);
1452     todo_wine expect(UnitPixel, unit);
1453     expectf(0.0, bounds.X);
1454     expectf(0.0, bounds.Y);
1455     todo_wine expectf(320.0, bounds.Width);
1456     todo_wine expectf(320.0, bounds.Height);
1457
1458     stat = GdipGetImageHorizontalResolution(img, &res);
1459     expect(Ok, stat);
1460     todo_wine expectf(1440.0, res);
1461
1462     stat = GdipGetImageVerticalResolution(img, &res);
1463     expect(Ok, stat);
1464     todo_wine expectf(1440.0, res);
1465
1466     memset(&header, 0, sizeof(header));
1467     stat = GdipGetMetafileHeaderFromMetafile((GpMetafile*)img, &header);
1468     expect(Ok, stat);
1469     if (stat == Ok)
1470     {
1471         todo_wine expect(MetafileTypeWmfPlaceable, header.Type);
1472         todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
1473         todo_wine expect(0x300, header.Version);
1474         expect(0, header.EmfPlusFlags);
1475         todo_wine expectf(1440.0, header.DpiX);
1476         todo_wine expectf(1440.0, header.DpiY);
1477         expect(0, header.X);
1478         expect(0, header.Y);
1479         todo_wine expect(320, header.Width);
1480         todo_wine expect(320, header.Height);
1481         todo_wine expect(1, U(header).WmfHeader.mtType);
1482         expect(0, header.EmfPlusHeaderSize);
1483         expect(0, header.LogicalDpiX);
1484         expect(0, header.LogicalDpiY);
1485     }
1486
1487     GdipDisposeImage(img);
1488 }
1489
1490 static void test_createfromwmf(void)
1491 {
1492     HMETAFILE hwmf;
1493     GpImage *img;
1494     GpStatus stat;
1495     GpRectF bounds;
1496     GpUnit unit;
1497     REAL res = 12345.0;
1498     MetafileHeader header;
1499
1500     hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
1501         wmfimage+sizeof(WmfPlaceableFileHeader));
1502     ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
1503
1504     stat = GdipCreateMetafileFromWmf(hwmf, TRUE,
1505         (WmfPlaceableFileHeader*)wmfimage, (GpMetafile**)&img);
1506     expect(Ok, stat);
1507     if (stat != Ok) return; // ReactOS
1508
1509     stat = GdipGetImageBounds(img, &bounds, &unit);
1510     expect(Ok, stat);
1511     expect(UnitPixel, unit);
1512     expectf(0.0, bounds.X);
1513     expectf(0.0, bounds.Y);
1514     expectf(320.0, bounds.Width);
1515     expectf(320.0, bounds.Height);
1516
1517     stat = GdipGetImageHorizontalResolution(img, &res);
1518     expect(Ok, stat);
1519     expectf(1440.0, res);
1520
1521     stat = GdipGetImageVerticalResolution(img, &res);
1522     expect(Ok, stat);
1523     expectf(1440.0, res);
1524
1525     memset(&header, 0, sizeof(header));
1526     stat = GdipGetMetafileHeaderFromMetafile((GpMetafile*)img, &header);
1527     expect(Ok, stat);
1528     if (stat == Ok)
1529     {
1530         todo_wine expect(MetafileTypeWmfPlaceable, header.Type);
1531         todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
1532         todo_wine expect(0x300, header.Version);
1533         expect(0, header.EmfPlusFlags);
1534         todo_wine expectf(1440.0, header.DpiX);
1535         todo_wine expectf(1440.0, header.DpiY);
1536         expect(0, header.X);
1537         expect(0, header.Y);
1538         todo_wine expect(320, header.Width);
1539         todo_wine expect(320, header.Height);
1540         todo_wine expect(1, U(header).WmfHeader.mtType);
1541         expect(0, header.EmfPlusHeaderSize);
1542         expect(0, header.LogicalDpiX);
1543         expect(0, header.LogicalDpiY);
1544     }
1545
1546     GdipDisposeImage(img);
1547 }
1548
1549 static void test_resolution(void)
1550 {
1551     GpStatus stat;
1552     GpBitmap *bitmap;
1553     GpGraphics *graphics;
1554     REAL res=-1.0;
1555     HDC screendc;
1556     int screenxres, screenyres;
1557
1558     /* create Bitmap */
1559     stat = GdipCreateBitmapFromScan0(1, 1, 32, PixelFormat24bppRGB, NULL, &bitmap);
1560     expect(Ok, stat);
1561
1562     /* test invalid values */
1563     stat = GdipGetImageHorizontalResolution(NULL, &res);
1564     expect(InvalidParameter, stat);
1565
1566     stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, NULL);
1567     expect(InvalidParameter, stat);
1568
1569     stat = GdipGetImageVerticalResolution(NULL, &res);
1570     expect(InvalidParameter, stat);
1571
1572     stat = GdipGetImageVerticalResolution((GpImage*)bitmap, NULL);
1573     expect(InvalidParameter, stat);
1574
1575     stat = GdipBitmapSetResolution(NULL, 96.0, 96.0);
1576     expect(InvalidParameter, stat);
1577
1578     stat = GdipBitmapSetResolution(bitmap, 0.0, 0.0);
1579     expect(InvalidParameter, stat);
1580
1581     /* defaults to screen resolution */
1582     screendc = GetDC(0);
1583
1584     screenxres = GetDeviceCaps(screendc, LOGPIXELSX);
1585     screenyres = GetDeviceCaps(screendc, LOGPIXELSY);
1586
1587     ReleaseDC(0, screendc);
1588
1589     stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &res);
1590     expect(Ok, stat);
1591     expectf((REAL)screenxres, res);
1592
1593     stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &res);
1594     expect(Ok, stat);
1595     expectf((REAL)screenyres, res);
1596
1597     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
1598     expect(Ok, stat);
1599     stat = GdipGetDpiX(graphics, &res);
1600     expect(Ok, stat);
1601     expectf((REAL)screenxres, res);
1602     stat = GdipGetDpiY(graphics, &res);
1603     expect(Ok, stat);
1604     expectf((REAL)screenyres, res);
1605
1606     /* test changing the resolution */
1607     stat = GdipBitmapSetResolution(bitmap, screenxres*2.0, screenyres*3.0);
1608     expect(Ok, stat);
1609
1610     stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &res);
1611     expect(Ok, stat);
1612     expectf(screenxres*2.0, res);
1613
1614     stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &res);
1615     expect(Ok, stat);
1616     expectf(screenyres*3.0, res);
1617
1618     stat = GdipGetDpiX(graphics, &res);
1619     expect(Ok, stat);
1620     expectf((REAL)screenxres, res);
1621     stat = GdipGetDpiY(graphics, &res);
1622     expect(Ok, stat);
1623     expectf((REAL)screenyres, res);
1624
1625     stat = GdipDeleteGraphics(graphics);
1626     expect(Ok, stat);
1627
1628     stat = GdipGetImageGraphicsContext((GpImage*)bitmap, &graphics);
1629     expect(Ok, stat);
1630     stat = GdipGetDpiX(graphics, &res);
1631     expect(Ok, stat);
1632     expectf(screenxres*2.0, res);
1633     stat = GdipGetDpiY(graphics, &res);
1634     expect(Ok, stat);
1635     expectf(screenyres*3.0, res);
1636     stat = GdipDeleteGraphics(graphics);
1637     expect(Ok, stat);
1638
1639     stat = GdipDisposeImage((GpImage*)bitmap);
1640     expect(Ok, stat);
1641 }
1642
1643 static void test_createhbitmap(void)
1644 {
1645     GpStatus stat;
1646     GpBitmap *bitmap;
1647     HBITMAP hbitmap, oldhbitmap;
1648     BITMAP bm;
1649     int ret;
1650     HDC hdc;
1651     COLORREF pixel;
1652     BYTE bits[640];
1653
1654     memset(bits, 0x68, 640);
1655
1656     /* create Bitmap */
1657     stat = GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB, bits, &bitmap);
1658     expect(Ok, stat);
1659
1660     /* test NULL values */
1661     stat = GdipCreateHBITMAPFromBitmap(NULL, &hbitmap, 0);
1662     expect(InvalidParameter, stat);
1663
1664     stat = GdipCreateHBITMAPFromBitmap(bitmap, NULL, 0);
1665     expect(InvalidParameter, stat);
1666
1667     /* create HBITMAP */
1668     stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
1669     expect(Ok, stat);
1670
1671     if (stat == Ok)
1672     {
1673         ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1674         expect(sizeof(BITMAP), ret);
1675
1676         expect(0, bm.bmType);
1677         expect(10, bm.bmWidth);
1678         expect(20, bm.bmHeight);
1679         expect(40, bm.bmWidthBytes);
1680         expect(1, bm.bmPlanes);
1681         expect(32, bm.bmBitsPixel);
1682         ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1683
1684         if (bm.bmBits)
1685         {
1686             DWORD val = *(DWORD*)bm.bmBits;
1687             ok(val == 0xff686868, "got %x, expected 0xff686868\n", val);
1688         }
1689
1690         hdc = CreateCompatibleDC(NULL);
1691
1692         oldhbitmap = SelectObject(hdc, hbitmap);
1693         pixel = GetPixel(hdc, 5, 5);
1694         SelectObject(hdc, oldhbitmap);
1695
1696         DeleteDC(hdc);
1697
1698         expect(0x686868, pixel);
1699
1700         DeleteObject(hbitmap);
1701     }
1702
1703     stat = GdipDisposeImage((GpImage*)bitmap);
1704     expect(Ok, stat);
1705
1706     /* create alpha Bitmap */
1707     stat = GdipCreateBitmapFromScan0(8, 20, 32, PixelFormat32bppARGB, bits, &bitmap);
1708     expect(Ok, stat);
1709
1710     /* create HBITMAP */
1711     stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
1712     expect(Ok, stat);
1713
1714     if (stat == Ok)
1715     {
1716         ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1717         expect(sizeof(BITMAP), ret);
1718
1719         expect(0, bm.bmType);
1720         expect(8, bm.bmWidth);
1721         expect(20, bm.bmHeight);
1722         expect(32, bm.bmWidthBytes);
1723         expect(1, bm.bmPlanes);
1724         expect(32, bm.bmBitsPixel);
1725         ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1726
1727         if (bm.bmBits)
1728         {
1729             DWORD val = *(DWORD*)bm.bmBits;
1730             ok(val == 0x682a2a2a, "got %x, expected 0x682a2a2a\n", val);
1731         }
1732
1733         hdc = CreateCompatibleDC(NULL);
1734
1735         oldhbitmap = SelectObject(hdc, hbitmap);
1736         pixel = GetPixel(hdc, 5, 5);
1737         SelectObject(hdc, oldhbitmap);
1738
1739         DeleteDC(hdc);
1740
1741         expect(0x2a2a2a, pixel);
1742
1743         DeleteObject(hbitmap);
1744     }
1745
1746     stat = GdipDisposeImage((GpImage*)bitmap);
1747     expect(Ok, stat);
1748 }
1749
1750 static void test_getthumbnail(void)
1751 {
1752     GpStatus stat;
1753     GpImage *bitmap1, *bitmap2;
1754     UINT width, height;
1755
1756     stat = GdipGetImageThumbnail(NULL, 0, 0, &bitmap2, NULL, NULL);
1757     expect(InvalidParameter, stat);
1758
1759     stat = GdipCreateBitmapFromScan0(128, 128, 0, PixelFormat32bppRGB, NULL, (GpBitmap**)&bitmap1);
1760     expect(Ok, stat);
1761
1762     stat = GdipGetImageThumbnail(bitmap1, 0, 0, NULL, NULL, NULL);
1763     expect(InvalidParameter, stat);
1764
1765     stat = GdipGetImageThumbnail(bitmap1, 0, 0, &bitmap2, NULL, NULL);
1766     expect(Ok, stat);
1767
1768     if (stat == Ok)
1769     {
1770         stat = GdipGetImageWidth(bitmap2, &width);
1771         expect(Ok, stat);
1772         expect(120, width);
1773
1774         stat = GdipGetImageHeight(bitmap2, &height);
1775         expect(Ok, stat);
1776         expect(120, height);
1777
1778         GdipDisposeImage(bitmap2);
1779     }
1780
1781     GdipDisposeImage(bitmap1);
1782
1783
1784     stat = GdipCreateBitmapFromScan0(64, 128, 0, PixelFormat32bppRGB, NULL, (GpBitmap**)&bitmap1);
1785     expect(Ok, stat);
1786
1787     stat = GdipGetImageThumbnail(bitmap1, 32, 32, &bitmap2, NULL, NULL);
1788     expect(Ok, stat);
1789
1790     if (stat == Ok)
1791     {
1792         stat = GdipGetImageWidth(bitmap2, &width);
1793         expect(Ok, stat);
1794         expect(32, width);
1795
1796         stat = GdipGetImageHeight(bitmap2, &height);
1797         expect(Ok, stat);
1798         expect(32, height);
1799
1800         GdipDisposeImage(bitmap2);
1801     }
1802
1803     stat = GdipGetImageThumbnail(bitmap1, 0, 0, &bitmap2, NULL, NULL);
1804     expect(Ok, stat);
1805
1806     if (stat == Ok)
1807     {
1808         stat = GdipGetImageWidth(bitmap2, &width);
1809         expect(Ok, stat);
1810         expect(120, width);
1811
1812         stat = GdipGetImageHeight(bitmap2, &height);
1813         expect(Ok, stat);
1814         expect(120, height);
1815
1816         GdipDisposeImage(bitmap2);
1817     }
1818
1819     GdipDisposeImage(bitmap1);
1820 }
1821
1822 static void test_getsetpixel(void)
1823 {
1824     GpStatus stat;
1825     GpBitmap *bitmap;
1826     ARGB color;
1827     BYTE bits[16] = {0x00,0x00,0x00,0x00, 0x00,0xff,0xff,0x00,
1828                      0xff,0x00,0x00,0x00, 0xff,0xff,0xff,0x00};
1829
1830     stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB, bits, &bitmap);
1831     expect(Ok, stat);
1832
1833     /* null parameters */
1834     stat = GdipBitmapGetPixel(NULL, 1, 1, &color);
1835     expect(InvalidParameter, stat);
1836
1837     stat = GdipBitmapGetPixel(bitmap, 1, 1, NULL);
1838     expect(InvalidParameter, stat);
1839
1840     stat = GdipBitmapSetPixel(NULL, 1, 1, 0);
1841     expect(InvalidParameter, stat);
1842
1843     /* out of bounds */
1844     stat = GdipBitmapGetPixel(bitmap, -1, 1, &color);
1845     expect(InvalidParameter, stat);
1846
1847     stat = GdipBitmapSetPixel(bitmap, -1, 1, 0);
1848     expect(InvalidParameter, stat);
1849
1850     stat = GdipBitmapGetPixel(bitmap, 1, -1, &color);
1851     ok(stat == InvalidParameter ||
1852        broken(stat == Ok), /* Older gdiplus */
1853        "Expected InvalidParameter, got %.8x\n", stat);
1854
1855 if (0) /* crashes some gdiplus implementations */
1856 {
1857     stat = GdipBitmapSetPixel(bitmap, 1, -1, 0);
1858     ok(stat == InvalidParameter ||
1859        broken(stat == Ok), /* Older gdiplus */
1860        "Expected InvalidParameter, got %.8x\n", stat);
1861 }
1862
1863     stat = GdipBitmapGetPixel(bitmap, 2, 1, &color);
1864     expect(InvalidParameter, stat);
1865
1866     stat = GdipBitmapSetPixel(bitmap, 2, 1, 0);
1867     expect(InvalidParameter, stat);
1868
1869     stat = GdipBitmapGetPixel(bitmap, 1, 2, &color);
1870     expect(InvalidParameter, stat);
1871
1872     stat = GdipBitmapSetPixel(bitmap, 1, 2, 0);
1873     expect(InvalidParameter, stat);
1874
1875     /* valid use */
1876     stat = GdipBitmapGetPixel(bitmap, 1, 1, &color);
1877     expect(Ok, stat);
1878     expect(0xffffffff, color);
1879
1880     stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
1881     expect(Ok, stat);
1882     expect(0xff0000ff, color);
1883
1884     stat = GdipBitmapSetPixel(bitmap, 1, 1, 0xff676869);
1885     expect(Ok, stat);
1886
1887     stat = GdipBitmapSetPixel(bitmap, 0, 0, 0xff474849);
1888     expect(Ok, stat);
1889
1890     stat = GdipBitmapGetPixel(bitmap, 1, 1, &color);
1891     expect(Ok, stat);
1892     expect(0xff676869, color);
1893
1894     stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1895     expect(Ok, stat);
1896     expect(0xff474849, color);
1897
1898     stat = GdipDisposeImage((GpImage*)bitmap);
1899     expect(Ok, stat);
1900 }
1901
1902 static void check_halftone_palette(ColorPalette *palette)
1903 {
1904     static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1905     UINT i;
1906
1907     for (i=0; i<palette->Count; i++)
1908     {
1909         ARGB expected=0xff000000;
1910         if (i<8)
1911         {
1912             if (i&1) expected |= 0x800000;
1913             if (i&2) expected |= 0x8000;
1914             if (i&4) expected |= 0x80;
1915         }
1916         else if (i == 8)
1917         {
1918             expected = 0xffc0c0c0;
1919         }
1920         else if (i < 16)
1921         {
1922             if (i&1) expected |= 0xff0000;
1923             if (i&2) expected |= 0xff00;
1924             if (i&4) expected |= 0xff;
1925         }
1926         else if (i < 40)
1927         {
1928             expected = 0x00000000;
1929         }
1930         else
1931         {
1932             expected |= halftone_values[(i-40)%6];
1933             expected |= halftone_values[((i-40)/6)%6] << 8;
1934             expected |= halftone_values[((i-40)/36)%6] << 16;
1935         }
1936         ok(expected == palette->Entries[i], "Expected %.8x, got %.8x, i=%u/%u\n",
1937             expected, palette->Entries[i], i, palette->Count);
1938     }
1939 }
1940
1941 static void test_palette(void)
1942 {
1943     GpStatus stat;
1944     GpBitmap *bitmap;
1945     INT size;
1946     BYTE buffer[1040];
1947     ColorPalette *palette=(ColorPalette*)buffer;
1948     ARGB *entries = palette->Entries;
1949     ARGB color=0;
1950
1951     /* test initial palette from non-indexed bitmap */
1952     stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB, NULL, &bitmap);
1953     expect(Ok, stat);
1954
1955     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1956     expect(Ok, stat);
1957     expect(sizeof(UINT)*2+sizeof(ARGB), size);
1958
1959     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1960     expect(Ok, stat);
1961     expect(0, palette->Count);
1962
1963     /* test setting palette on not-indexed bitmap */
1964     palette->Count = 3;
1965
1966     stat = GdipSetImagePalette((GpImage*)bitmap, palette);
1967     expect(Ok, stat);
1968
1969     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1970     expect(Ok, stat);
1971     expect(sizeof(UINT)*2+sizeof(ARGB)*3, size);
1972
1973     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1974     expect(Ok, stat);
1975     expect(3, palette->Count);
1976
1977     GdipDisposeImage((GpImage*)bitmap);
1978
1979     /* test initial palette on 1-bit bitmap */
1980     stat = GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat1bppIndexed, NULL, &bitmap);
1981     expect(Ok, stat);
1982
1983     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1984     expect(Ok, stat);
1985     expect(sizeof(UINT)*2+sizeof(ARGB)*2, size);
1986
1987     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1988     expect(Ok, stat);
1989     expect(PaletteFlagsGrayScale, palette->Flags);
1990     expect(2, palette->Count);
1991
1992     expect(0xff000000, entries[0]);
1993     expect(0xffffffff, entries[1]);
1994
1995     /* test getting/setting pixels */
1996     stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1997     expect(Ok, stat);
1998     expect(0xff000000, color);
1999
2000     stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffffffff);
2001     ok((stat == Ok) ||
2002        broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
2003
2004     if (stat == Ok)
2005     {
2006         stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
2007         expect(Ok, stat);
2008         expect(0xffffffff, color);
2009     }
2010
2011     GdipDisposeImage((GpImage*)bitmap);
2012
2013     /* test initial palette on 4-bit bitmap */
2014     stat = GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat4bppIndexed, NULL, &bitmap);
2015     expect(Ok, stat);
2016
2017     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2018     expect(Ok, stat);
2019     expect(sizeof(UINT)*2+sizeof(ARGB)*16, size);
2020
2021     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2022     expect(Ok, stat);
2023     expect(0, palette->Flags);
2024     expect(16, palette->Count);
2025
2026     check_halftone_palette(palette);
2027
2028     /* test getting/setting pixels */
2029     stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
2030     expect(Ok, stat);
2031     expect(0xff000000, color);
2032
2033     stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffff00ff);
2034     ok((stat == Ok) ||
2035        broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
2036
2037     if (stat == Ok)
2038     {
2039         stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
2040         expect(Ok, stat);
2041         expect(0xffff00ff, color);
2042     }
2043
2044     GdipDisposeImage((GpImage*)bitmap);
2045
2046     /* test initial palette on 8-bit bitmap */
2047     stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat8bppIndexed, NULL, &bitmap);
2048     expect(Ok, stat);
2049
2050     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2051     expect(Ok, stat);
2052     expect(sizeof(UINT)*2+sizeof(ARGB)*256, size);
2053
2054     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2055     expect(Ok, stat);
2056     expect(PaletteFlagsHalftone, palette->Flags);
2057     expect(256, palette->Count);
2058
2059     check_halftone_palette(palette);
2060
2061     /* test getting/setting pixels */
2062     stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
2063     expect(Ok, stat);
2064     expect(0xff000000, color);
2065
2066     stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffcccccc);
2067     ok((stat == Ok) ||
2068        broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
2069
2070     if (stat == Ok)
2071     {
2072         stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
2073         expect(Ok, stat);
2074         expect(0xffcccccc, color);
2075     }
2076
2077     /* test setting/getting a different palette */
2078     entries[1] = 0xffcccccc;
2079
2080     stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2081     expect(Ok, stat);
2082
2083     entries[1] = 0;
2084
2085     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2086     expect(Ok, stat);
2087     expect(sizeof(UINT)*2+sizeof(ARGB)*256, size);
2088
2089     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2090     expect(Ok, stat);
2091     expect(PaletteFlagsHalftone, palette->Flags);
2092     expect(256, palette->Count);
2093     expect(0xffcccccc, entries[1]);
2094
2095     /* test count < 256 */
2096     palette->Flags = 12345;
2097     palette->Count = 3;
2098
2099     stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2100     expect(Ok, stat);
2101
2102     entries[1] = 0;
2103     entries[3] = 0xdeadbeef;
2104
2105     stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2106     expect(Ok, stat);
2107     expect(sizeof(UINT)*2+sizeof(ARGB)*3, size);
2108
2109     stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2110     expect(Ok, stat);
2111     expect(12345, palette->Flags);
2112     expect(3, palette->Count);
2113     expect(0xffcccccc, entries[1]);
2114     expect(0xdeadbeef, entries[3]);
2115
2116     /* test count > 256 */
2117     palette->Count = 257;
2118
2119     stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2120     ok(stat == InvalidParameter ||
2121        broken(stat == Ok), /* Old gdiplus behavior */
2122        "Expected %.8x, got %.8x\n", InvalidParameter, stat);
2123
2124     GdipDisposeImage((GpImage*)bitmap);
2125 }
2126
2127 static void test_colormatrix(void)
2128 {
2129     GpStatus stat;
2130     ColorMatrix colormatrix, graymatrix;
2131     GpImageAttributes *imageattr;
2132     const ColorMatrix identity = {{
2133         {1.0,0.0,0.0,0.0,0.0},
2134         {0.0,1.0,0.0,0.0,0.0},
2135         {0.0,0.0,1.0,0.0,0.0},
2136         {0.0,0.0,0.0,1.0,0.0},
2137         {0.0,0.0,0.0,0.0,1.0}}};
2138     const ColorMatrix double_red = {{
2139         {2.0,0.0,0.0,0.0,0.0},
2140         {0.0,1.0,0.0,0.0,0.0},
2141         {0.0,0.0,1.0,0.0,0.0},
2142         {0.0,0.0,0.0,1.0,0.0},
2143         {0.0,0.0,0.0,0.0,1.0}}};
2144     const ColorMatrix asymmetric = {{
2145         {0.0,1.0,0.0,0.0,0.0},
2146         {0.0,0.0,1.0,0.0,0.0},
2147         {0.0,0.0,0.0,1.0,0.0},
2148         {1.0,0.0,0.0,0.0,0.0},
2149         {0.0,0.0,0.0,0.0,1.0}}};
2150     GpBitmap *bitmap1, *bitmap2;
2151     GpGraphics *graphics;
2152     ARGB color;
2153
2154     colormatrix = identity;
2155     graymatrix = identity;
2156
2157     stat = GdipSetImageAttributesColorMatrix(NULL, ColorAdjustTypeDefault,
2158         TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2159     expect(InvalidParameter, stat);
2160
2161     stat = GdipCreateImageAttributes(&imageattr);
2162     expect(Ok, stat);
2163
2164     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2165         TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2166     expect(Ok, stat);
2167
2168     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2169         TRUE, NULL, NULL, ColorMatrixFlagsDefault);
2170     expect(InvalidParameter, stat);
2171
2172     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2173         TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2174     expect(Ok, stat);
2175
2176     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2177         TRUE, &colormatrix, NULL, ColorMatrixFlagsSkipGrays);
2178     expect(Ok, stat);
2179
2180     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2181         TRUE, &colormatrix, NULL, ColorMatrixFlagsAltGray);
2182     expect(InvalidParameter, stat);
2183
2184     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2185         TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsAltGray);
2186     expect(Ok, stat);
2187
2188     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2189         TRUE, &colormatrix, &graymatrix, 3);
2190     expect(InvalidParameter, stat);
2191
2192     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeCount,
2193         TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2194     expect(InvalidParameter, stat);
2195
2196     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeAny,
2197         TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2198     expect(InvalidParameter, stat);
2199
2200     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2201         FALSE, NULL, NULL, ColorMatrixFlagsDefault);
2202     expect(Ok, stat);
2203
2204     /* Drawing a bitmap transforms the colors */
2205     colormatrix = double_red;
2206     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2207         TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2208     expect(Ok, stat);
2209
2210     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap1);
2211     expect(Ok, stat);
2212
2213     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap2);
2214     expect(Ok, stat);
2215
2216     stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff40ccee);
2217     expect(Ok, stat);
2218
2219     stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2220     expect(Ok, stat);
2221
2222     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2223         UnitPixel, imageattr, NULL, NULL);
2224     expect(Ok, stat);
2225
2226     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2227     expect(Ok, stat);
2228     expect(0xff80ccee, color);
2229
2230     colormatrix = asymmetric;
2231     stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2232         TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2233     expect(Ok, stat);
2234
2235     stat = GdipBitmapSetPixel(bitmap2, 0, 0, 0);
2236     expect(Ok, stat);
2237
2238     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2239         UnitPixel, imageattr, NULL, NULL);
2240     expect(Ok, stat);
2241
2242     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2243     expect(Ok, stat);
2244     ok(color_match(0xeeff40cc, color, 3), "expected 0xeeff40cc, got 0x%08x\n", color);
2245
2246     stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
2247     expect(Ok, stat);
2248
2249     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2250         UnitPixel, imageattr, NULL, NULL);
2251     expect(Ok, stat);
2252
2253     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2254     expect(Ok, stat);
2255     ok(color_match(0xff40ccee, color, 1), "Expected ff40ccee, got %.8x\n", color);
2256
2257     GdipDeleteGraphics(graphics);
2258     GdipDisposeImage((GpImage*)bitmap1);
2259     GdipDisposeImage((GpImage*)bitmap2);
2260     GdipDisposeImageAttributes(imageattr);
2261 }
2262
2263 static void test_gamma(void)
2264 {
2265     GpStatus stat;
2266     GpImageAttributes *imageattr;
2267     GpBitmap *bitmap1, *bitmap2;
2268     GpGraphics *graphics;
2269     ARGB color;
2270
2271     stat = GdipSetImageAttributesGamma(NULL, ColorAdjustTypeDefault, TRUE, 1.0);
2272     expect(InvalidParameter, stat);
2273
2274     stat = GdipCreateImageAttributes(&imageattr);
2275     expect(Ok, stat);
2276
2277     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 1.0);
2278     expect(Ok, stat);
2279
2280     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeAny, TRUE, 1.0);
2281     expect(InvalidParameter, stat);
2282
2283     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, -1.0);
2284     expect(InvalidParameter, stat);
2285
2286     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.0);
2287     expect(InvalidParameter, stat);
2288
2289     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.5);
2290     expect(Ok, stat);
2291
2292     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, FALSE, 0.0);
2293     expect(Ok, stat);
2294
2295     /* Drawing a bitmap transforms the colors */
2296     stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 3.0);
2297     expect(Ok, stat);
2298
2299     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap1);
2300     expect(Ok, stat);
2301
2302     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap2);
2303     expect(Ok, stat);
2304
2305     stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff80ffff);
2306     expect(Ok, stat);
2307
2308     stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2309     expect(Ok, stat);
2310
2311     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2312         UnitPixel, imageattr, NULL, NULL);
2313     expect(Ok, stat);
2314
2315     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2316     expect(Ok, stat);
2317     ok(color_match(0xff20ffff, color, 1), "Expected ff20ffff, got %.8x\n", color);
2318
2319     stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
2320     expect(Ok, stat);
2321
2322     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2323         UnitPixel, imageattr, NULL, NULL);
2324     expect(Ok, stat);
2325
2326     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2327     expect(Ok, stat);
2328     ok(color_match(0xff80ffff, color, 1), "Expected ff80ffff, got %.8x\n", color);
2329
2330     GdipDeleteGraphics(graphics);
2331     GdipDisposeImage((GpImage*)bitmap1);
2332     GdipDisposeImage((GpImage*)bitmap2);
2333     GdipDisposeImageAttributes(imageattr);
2334 }
2335
2336 /* 1x1 pixel gif, 2 frames; first frame is white, second is black */
2337 static const unsigned char gifanimation[72] = {
2338 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
2339 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x21,0xf9,0x04,0x00,0x0a,0x00,0xff,
2340 0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x4c,0x01,0x00,
2341 0x21,0xf9,0x04,0x01,0x0a,0x00,0x01,0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
2342 0x00,0x00,0x02,0x02,0x44,0x01,0x00,0x3b
2343 };
2344
2345 static void test_multiframegif(void)
2346 {
2347     LPSTREAM stream;
2348     HGLOBAL hglob;
2349     LPBYTE data;
2350     HRESULT hres;
2351     GpStatus stat;
2352     GpBitmap *bmp;
2353     ARGB color;
2354     UINT count;
2355     GUID dimension;
2356
2357     /* Test frame functions with an animated GIF */
2358     hglob = GlobalAlloc (0, sizeof(gifanimation));
2359     data = GlobalLock (hglob);
2360     memcpy(data, gifanimation, sizeof(gifanimation));
2361     GlobalUnlock(hglob);
2362
2363     hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
2364     ok(hres == S_OK, "Failed to create a stream\n");
2365     if(hres != S_OK) return;
2366
2367     stat = GdipCreateBitmapFromStream(stream, &bmp);
2368     ok(stat == Ok, "Failed to create a Bitmap\n");
2369     if(stat != Ok){
2370         IStream_Release(stream);
2371         return;
2372     }
2373
2374     /* Bitmap starts at frame 0 */
2375     color = 0xdeadbeef;
2376     stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2377     expect(Ok, stat);
2378     expect(0xffffffff, color);
2379
2380     /* Check that we get correct metadata */
2381     stat = GdipImageGetFrameDimensionsCount((GpImage*)bmp,&count);
2382     expect(Ok, stat);
2383     expect(1, count);
2384
2385     stat = GdipImageGetFrameDimensionsList((GpImage*)bmp, &dimension, 1);
2386     expect(Ok, stat);
2387     expect_guid(&FrameDimensionTime, &dimension, __LINE__, FALSE);
2388
2389     count = 12345;
2390     stat = GdipImageGetFrameCount((GpImage*)bmp, &dimension, &count);
2391     expect(Ok, stat);
2392     expect(2, count);
2393
2394     /* SelectActiveFrame overwrites our current data */
2395     stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 1);
2396     expect(Ok, stat);
2397
2398     color = 0xdeadbeef;
2399     GdipBitmapGetPixel(bmp, 0, 0, &color);
2400     expect(Ok, stat);
2401     expect(0xff000000, color);
2402
2403     stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2404     expect(Ok, stat);
2405
2406     color = 0xdeadbeef;
2407     GdipBitmapGetPixel(bmp, 0, 0, &color);
2408     expect(Ok, stat);
2409     expect(0xffffffff, color);
2410
2411     /* Write over the image data */
2412     stat = GdipBitmapSetPixel(bmp, 0, 0, 0xff000000);
2413     expect(Ok, stat);
2414
2415     /* Switching to the same frame does not overwrite our changes */
2416     stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2417     expect(Ok, stat);
2418
2419     stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2420     expect(Ok, stat);
2421     expect(0xff000000, color);
2422
2423     /* But switching to another frame and back does */
2424     stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 1);
2425     expect(Ok, stat);
2426
2427     stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2428     expect(Ok, stat);
2429
2430     stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2431     expect(Ok, stat);
2432     expect(0xffffffff, color);
2433
2434     /* rotate/flip discards the information about other frames */
2435     stat = GdipImageRotateFlip((GpImage*)bmp, Rotate90FlipNone);
2436     expect(Ok, stat);
2437
2438     count = 12345;
2439     stat = GdipImageGetFrameCount((GpImage*)bmp, &dimension, &count);
2440     expect(Ok, stat);
2441     expect(1, count);
2442
2443     expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bmp, __LINE__, FALSE);
2444
2445     GdipDisposeImage((GpImage*)bmp);
2446     IStream_Release(stream);
2447
2448     /* Test with a non-animated gif */
2449     hglob = GlobalAlloc (0, sizeof(gifimage));
2450     data = GlobalLock (hglob);
2451     memcpy(data, gifimage, sizeof(gifimage));
2452     GlobalUnlock(hglob);
2453
2454     hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
2455     ok(hres == S_OK, "Failed to create a stream\n");
2456     if(hres != S_OK) return;
2457
2458     stat = GdipCreateBitmapFromStream(stream, &bmp);
2459     ok(stat == Ok, "Failed to create a Bitmap\n");
2460     if(stat != Ok){
2461         IStream_Release(stream);
2462         return;
2463     }
2464
2465     /* Check metadata */
2466     stat = GdipImageGetFrameDimensionsCount((GpImage*)bmp,&count);
2467     expect(Ok, stat);
2468     expect(1, count);
2469
2470     stat = GdipImageGetFrameDimensionsList((GpImage*)bmp, &dimension, 1);
2471     expect(Ok, stat);
2472     expect_guid(&FrameDimensionTime, &dimension, __LINE__, FALSE);
2473
2474     count = 12345;
2475     stat = GdipImageGetFrameCount((GpImage*)bmp, &dimension, &count);
2476     expect(Ok, stat);
2477     expect(1, count);
2478
2479     GdipDisposeImage((GpImage*)bmp);
2480     IStream_Release(stream);
2481 }
2482
2483 static void test_rotateflip(void)
2484 {
2485     GpImage *bitmap;
2486     GpStatus stat;
2487     BYTE bits[24];
2488     static const BYTE orig_bits[24] = {
2489         0,0,0xff,    0,0xff,0,    0xff,0,0,    23,23,23,
2490         0xff,0xff,0, 0xff,0,0xff, 0,0xff,0xff, 23,23,23};
2491     UINT width, height;
2492     ARGB color;
2493
2494     memcpy(bits, orig_bits, sizeof(bits));
2495     stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2496     expect(Ok, stat);
2497
2498     stat = GdipImageRotateFlip(bitmap, Rotate90FlipNone);
2499     expect(Ok, stat);
2500
2501     stat = GdipGetImageWidth(bitmap, &width);
2502     expect(Ok, stat);
2503     stat = GdipGetImageHeight(bitmap, &height);
2504     expect(Ok, stat);
2505     expect(2, width);
2506     expect(3, height);
2507
2508     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2509     expect(Ok, stat);
2510     expect(0xff00ffff, color);
2511
2512     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 1, 0, &color);
2513     expect(Ok, stat);
2514     expect(0xffff0000, color);
2515
2516     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 2, &color);
2517     expect(Ok, stat);
2518     expect(0xffffff00, color);
2519
2520     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 1, 2, &color);
2521     expect(Ok, stat);
2522     expect(0xff0000ff, color);
2523
2524     expect(0, bits[0]);
2525     expect(0, bits[1]);
2526     expect(0xff, bits[2]);
2527
2528     GdipDisposeImage(bitmap);
2529
2530     memcpy(bits, orig_bits, sizeof(bits));
2531     stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2532     expect(Ok, stat);
2533
2534     stat = GdipImageRotateFlip(bitmap, RotateNoneFlipX);
2535     expect(Ok, stat);
2536
2537     stat = GdipGetImageWidth(bitmap, &width);
2538     expect(Ok, stat);
2539     stat = GdipGetImageHeight(bitmap, &height);
2540     expect(Ok, stat);
2541     expect(3, width);
2542     expect(2, height);
2543
2544     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2545     expect(Ok, stat);
2546     expect(0xff0000ff, color);
2547
2548     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 0, &color);
2549     expect(Ok, stat);
2550     expect(0xffff0000, color);
2551
2552     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 1, &color);
2553     expect(Ok, stat);
2554     expect(0xffffff00, color);
2555
2556     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 1, &color);
2557     expect(Ok, stat);
2558     expect(0xff00ffff, color);
2559
2560     expect(0, bits[0]);
2561     expect(0, bits[1]);
2562     expect(0xff, bits[2]);
2563
2564     GdipDisposeImage(bitmap);
2565
2566     memcpy(bits, orig_bits, sizeof(bits));
2567     stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2568     expect(Ok, stat);
2569
2570     stat = GdipImageRotateFlip(bitmap, RotateNoneFlipY);
2571     expect(Ok, stat);
2572
2573     stat = GdipGetImageWidth(bitmap, &width);
2574     expect(Ok, stat);
2575     stat = GdipGetImageHeight(bitmap, &height);
2576     expect(Ok, stat);
2577     expect(3, width);
2578     expect(2, height);
2579
2580     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2581     expect(Ok, stat);
2582     expect(0xff00ffff, color);
2583
2584     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 0, &color);
2585     expect(Ok, stat);
2586     expect(0xffffff00, color);
2587
2588     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 1, &color);
2589     expect(Ok, stat);
2590     expect(0xffff0000, color);
2591
2592     stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 1, &color);
2593     expect(Ok, stat);
2594     expect(0xff0000ff, color);
2595
2596     expect(0, bits[0]);
2597     expect(0, bits[1]);
2598     expect(0xff, bits[2]);
2599
2600     GdipDisposeImage(bitmap);
2601 }
2602
2603 static void test_remaptable(void)
2604 {
2605     GpStatus stat;
2606     GpImageAttributes *imageattr;
2607     GpBitmap *bitmap1, *bitmap2;
2608     GpGraphics *graphics;
2609     ARGB color;
2610     ColorMap *map;
2611
2612     map = GdipAlloc(sizeof(ColorMap));
2613
2614     map->oldColor.Argb = 0xff00ff00;
2615     map->newColor.Argb = 0xffff00ff;
2616
2617     stat = GdipSetImageAttributesRemapTable(NULL, ColorAdjustTypeDefault, TRUE, 1, map);
2618     expect(InvalidParameter, stat);
2619
2620     stat = GdipCreateImageAttributes(&imageattr);
2621     expect(Ok, stat);
2622
2623     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 1, NULL);
2624     expect(InvalidParameter, stat);
2625
2626     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeCount, TRUE, 1, map);
2627     expect(InvalidParameter, stat);
2628
2629     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeAny, TRUE, 1, map);
2630     expect(InvalidParameter, stat);
2631
2632     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 0, map);
2633     expect(InvalidParameter, stat);
2634
2635     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, FALSE, 0, NULL);
2636     expect(Ok, stat);
2637
2638     stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 1, map);
2639     expect(Ok, stat);
2640
2641     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap1);
2642     expect(Ok, stat);
2643
2644     stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap2);
2645     expect(Ok, stat);
2646
2647     stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff00ff00);
2648     expect(Ok, stat);
2649
2650     stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2651     expect(Ok, stat);
2652
2653     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2654         UnitPixel, imageattr, NULL, NULL);
2655     expect(Ok, stat);
2656
2657     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2658     expect(Ok, stat);
2659     ok(color_match(0xffff00ff, color, 1), "Expected ffff00ff, got %.8x\n", color);
2660
2661     stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
2662     expect(Ok, stat);
2663
2664     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2665         UnitPixel, imageattr, NULL, NULL);
2666     expect(Ok, stat);
2667
2668     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2669     expect(Ok, stat);
2670     ok(color_match(0xff00ff00, color, 1), "Expected ff00ff00, got %.8x\n", color);
2671
2672     GdipDeleteGraphics(graphics);
2673     GdipDisposeImage((GpImage*)bitmap1);
2674     GdipDisposeImage((GpImage*)bitmap2);
2675     GdipDisposeImageAttributes(imageattr);
2676     GdipFree(map);
2677 }
2678
2679 static void test_colorkey(void)
2680 {
2681     GpStatus stat;
2682     GpImageAttributes *imageattr;
2683     GpBitmap *bitmap1, *bitmap2;
2684     GpGraphics *graphics;
2685     ARGB color;
2686
2687     stat = GdipSetImageAttributesColorKeys(NULL, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
2688     expect(InvalidParameter, stat);
2689
2690     stat = GdipCreateImageAttributes(&imageattr);
2691     expect(Ok, stat);
2692
2693     stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeCount, TRUE, 0xff405060, 0xff708090);
2694     expect(InvalidParameter, stat);
2695
2696     stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeAny, TRUE, 0xff405060, 0xff708090);
2697     expect(InvalidParameter, stat);
2698
2699     stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
2700     expect(Ok, stat);
2701
2702     stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap1);
2703     expect(Ok, stat);
2704
2705     stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap2);
2706     expect(Ok, stat);
2707
2708     stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0x20405060);
2709     expect(Ok, stat);
2710
2711     stat = GdipBitmapSetPixel(bitmap1, 0, 1, 0x40506070);
2712     expect(Ok, stat);
2713
2714     stat = GdipBitmapSetPixel(bitmap1, 1, 0, 0x60708090);
2715     expect(Ok, stat);
2716
2717     stat = GdipBitmapSetPixel(bitmap1, 1, 1, 0xffffffff);
2718     expect(Ok, stat);
2719
2720     stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2721     expect(Ok, stat);
2722
2723     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
2724         UnitPixel, imageattr, NULL, NULL);
2725     expect(Ok, stat);
2726
2727     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2728     expect(Ok, stat);
2729     ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
2730
2731     stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
2732     expect(Ok, stat);
2733     ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
2734
2735     stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
2736     expect(Ok, stat);
2737     ok(color_match(0x00000000, color, 1), "Expected 00000000, got %.8x\n", color);
2738
2739     stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
2740     expect(Ok, stat);
2741     ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
2742
2743     stat = GdipResetImageAttributes(imageattr, ColorAdjustTypeDefault);
2744     expect(Ok, stat);
2745
2746     stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
2747         UnitPixel, imageattr, NULL, NULL);
2748     expect(Ok, stat);
2749
2750     stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2751     expect(Ok, stat);
2752     ok(color_match(0x20405060, color, 1), "Expected 20405060, got %.8x\n", color);
2753
2754     stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
2755     expect(Ok, stat);
2756     ok(color_match(0x40506070, color, 1), "Expected 40506070, got %.8x\n", color);
2757
2758     stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
2759     expect(Ok, stat);
2760     ok(color_match(0x60708090, color, 1), "Expected 60708090, got %.8x\n", color);
2761
2762     stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
2763     expect(Ok, stat);
2764     ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
2765
2766
2767     GdipDeleteGraphics(graphics);
2768     GdipDisposeImage((GpImage*)bitmap1);
2769     GdipDisposeImage((GpImage*)bitmap2);
2770     GdipDisposeImageAttributes(imageattr);
2771 }
2772
2773 static void test_dispose(void)
2774 {
2775     GpStatus stat;
2776     GpImage *image;
2777     char invalid_image[256];
2778
2779     stat = GdipDisposeImage(NULL);
2780     expect(InvalidParameter, stat);
2781
2782     stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, (GpBitmap**)&image);
2783     expect(Ok, stat);
2784
2785     stat = GdipDisposeImage(image);
2786     expect(Ok, stat);
2787
2788     stat = GdipDisposeImage(image);
2789     expect(ObjectBusy, stat);
2790
2791     memset(invalid_image, 0, 256);
2792     stat = GdipDisposeImage((GpImage*)invalid_image);
2793     expect(ObjectBusy, stat);
2794 }
2795
2796 static LONG obj_refcount(void *obj)
2797 {
2798     IUnknown_AddRef((IUnknown *)obj);
2799     return IUnknown_Release((IUnknown *)obj);
2800 }
2801
2802 static GpImage *load_image(const BYTE *image_data, UINT image_size)
2803 {
2804     IStream *stream;
2805     HGLOBAL hmem;
2806     BYTE *data;
2807     HRESULT hr;
2808     GpStatus status;
2809     GpImage *image = NULL, *clone;
2810     ImageType image_type;
2811     LONG refcount, old_refcount;
2812
2813     hmem = GlobalAlloc(0, image_size);
2814     data = GlobalLock(hmem);
2815     memcpy(data, image_data, image_size);
2816     GlobalUnlock(hmem);
2817
2818     hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
2819     ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
2820     if (hr != S_OK) return NULL;
2821
2822     refcount = obj_refcount(stream);
2823     ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
2824
2825     status = GdipLoadImageFromStream(stream, &image);
2826     ok(status == Ok || broken(status == InvalidParameter), /* XP */
2827        "GdipLoadImageFromStream error %d\n", status);
2828     if (status != Ok)
2829     {
2830         IStream_Release(stream);
2831         return NULL;
2832     }
2833
2834     status = GdipGetImageType(image, &image_type);
2835     ok(status == Ok, "GdipGetImageType error %d\n", status);
2836
2837     refcount = obj_refcount(stream);
2838     if (image_type == ImageTypeBitmap)
2839         ok(refcount > 1, "expected stream refcount > 1, got %d\n", refcount);
2840     else
2841         ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
2842     old_refcount = refcount;
2843
2844     status = GdipCloneImage(image, &clone);
2845     ok(status == Ok, "GdipCloneImage error %d\n", status);
2846     refcount = obj_refcount(stream);
2847     ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
2848     status = GdipDisposeImage(clone);
2849     ok(status == Ok, "GdipDisposeImage error %d\n", status);
2850     refcount = obj_refcount(stream);
2851     ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
2852
2853     refcount = IStream_Release(stream);
2854     if (image_type == ImageTypeBitmap)
2855         ok(refcount >= 1, "expected stream refcount != 0\n");
2856     else
2857         ok(refcount == 0, "expected stream refcount 0, got %d\n", refcount);
2858
2859     return image;
2860 }
2861
2862 static void test_image_properties(void)
2863 {
2864     static const struct test_data
2865     {
2866         const BYTE *image_data;
2867         UINT image_size;
2868         ImageType image_type;
2869         UINT prop_count;
2870         UINT prop_count2; /* if win7 behaves differently */
2871         /* 1st property attributes */
2872         UINT prop_size;
2873         UINT prop_size2; /* if win7 behaves differently */
2874         UINT prop_id;
2875         UINT prop_id2; /* if win7 behaves differently */
2876     }
2877     td[] =
2878     {
2879         { pngimage, sizeof(pngimage), ImageTypeBitmap, 4, ~0, 1, 20, 0x5110, 0x132 },
2880         { jpgimage, sizeof(jpgimage), ImageTypeBitmap, 2, ~0, 128, 0, 0x5090, 0x5091 },
2881         { tiffimage, sizeof(tiffimage), ImageTypeBitmap, 16, 0, 4, 0, 0xfe, 0 },
2882         { bmpimage, sizeof(bmpimage), ImageTypeBitmap, 0, 0, 0, 0, 0, 0 },
2883         { wmfimage, sizeof(wmfimage), ImageTypeMetafile, 0, 0, 0, 0, 0, 0 }
2884     };
2885     GpStatus status;
2886     GpImage *image;
2887     UINT prop_count, prop_size, i;
2888     PROPID prop_id[16] = { 0 };
2889     ImageType image_type;
2890     union
2891     {
2892         PropertyItem data;
2893         char buf[256];
2894     } item;
2895
2896     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
2897     {
2898         image = load_image(td[i].image_data, td[i].image_size);
2899         if (!image)
2900         {
2901             trace("%u: failed to load image data\n", i);
2902             continue;
2903         }
2904
2905         status = GdipGetImageType(image, &image_type);
2906         ok(status == Ok, "%u: GdipGetImageType error %d\n", i, status);
2907         ok(td[i].image_type == image_type, "%u: expected image_type %d, got %d\n",
2908            i, td[i].image_type, image_type);
2909
2910         status = GdipGetPropertyCount(image, &prop_count);
2911         ok(status == Ok, "%u: GdipGetPropertyCount error %d\n", i, status);
2912         if (td[i].image_data == pngimage || td[i].image_data == jpgimage)
2913         todo_wine
2914         ok(td[i].prop_count == prop_count || td[i].prop_count2 == prop_count,
2915            " %u: expected property count %u or %u, got %u\n",
2916            i, td[i].prop_count, td[i].prop_count2, prop_count);
2917         else
2918         ok(td[i].prop_count == prop_count || td[i].prop_count2 == prop_count,
2919            " %u: expected property count %u or %u, got %u\n",
2920            i, td[i].prop_count, td[i].prop_count2, prop_count);
2921
2922         status = GdipGetPropertyItemSize(NULL, 0, &prop_size);
2923         expect(InvalidParameter, status);
2924         status = GdipGetPropertyItemSize(image, 0, NULL);
2925         expect(InvalidParameter, status);
2926         status = GdipGetPropertyItemSize(image, 0, &prop_size);
2927         if (image_type == ImageTypeMetafile)
2928             expect(NotImplemented, status);
2929         else
2930             expect(PropertyNotFound, status);
2931
2932         status = GdipGetPropertyItem(NULL, 0, 0, &item.data);
2933         expect(InvalidParameter, status);
2934         status = GdipGetPropertyItem(image, 0, 0, NULL);
2935         expect(InvalidParameter, status);
2936         status = GdipGetPropertyItem(image, 0, 0, &item.data);
2937         if (image_type == ImageTypeMetafile)
2938             expect(NotImplemented, status);
2939         else
2940             expect(PropertyNotFound, status);
2941
2942         /* FIXME: remove once Wine is fixed */
2943         if (td[i].prop_count != prop_count)
2944         {
2945             GdipDisposeImage(image);
2946             continue;
2947         }
2948
2949         status = GdipGetPropertyIdList(NULL, prop_count, prop_id);
2950         expect(InvalidParameter, status);
2951         status = GdipGetPropertyIdList(image, prop_count, NULL);
2952         expect(InvalidParameter, status);
2953         status = GdipGetPropertyIdList(image, 0, prop_id);
2954         if (image_type == ImageTypeMetafile)
2955             expect(NotImplemented, status);
2956         else if (prop_count == 0)
2957             expect(Ok, status);
2958         else
2959             expect(InvalidParameter, status);
2960         status = GdipGetPropertyIdList(image, prop_count - 1, prop_id);
2961         if (image_type == ImageTypeMetafile)
2962             expect(NotImplemented, status);
2963         else
2964             expect(InvalidParameter, status);
2965         status = GdipGetPropertyIdList(image, prop_count + 1, prop_id);
2966         if (image_type == ImageTypeMetafile)
2967             expect(NotImplemented, status);
2968         else
2969             expect(InvalidParameter, status);
2970         status = GdipGetPropertyIdList(image, prop_count, prop_id);
2971         if (image_type == ImageTypeMetafile)
2972             expect(NotImplemented, status);
2973         else
2974         {
2975             expect(Ok, status);
2976             if (prop_count != 0)
2977                 ok(td[i].prop_id == prop_id[0] || td[i].prop_id2 == prop_id[0],
2978                    " %u: expected property id %#x or %#x, got %#x\n",
2979                    i, td[i].prop_id, td[i].prop_id2, prop_id[0]);
2980         }
2981
2982         if (status == Ok)
2983         {
2984             status = GdipGetPropertyItemSize(image, prop_id[0], &prop_size);
2985             if (prop_count == 0)
2986                 expect(PropertyNotFound, status);
2987             else
2988             {
2989                 expect(Ok, status);
2990
2991                 assert(sizeof(item) >= prop_size);
2992                 ok(prop_size > sizeof(PropertyItem), "%u: got too small prop_size %u\n",
2993                    i, prop_size);
2994                 ok(td[i].prop_size + sizeof(PropertyItem) == prop_size ||
2995                    td[i].prop_size2 + sizeof(PropertyItem) == prop_size,
2996                    " %u: expected property size %u or %u, got %u\n",
2997                    i, td[i].prop_size, td[i].prop_size2, prop_size);
2998
2999                 status = GdipGetPropertyItem(image, prop_id[0], 0, &item.data);
3000                 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3001                    "%u: expected InvalidParameter, got %d\n", i, status);
3002                 status = GdipGetPropertyItem(image, prop_id[0], prop_size - 1, &item.data);
3003                 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3004                    "%u: expected InvalidParameter, got %d\n", i, status);
3005                 status = GdipGetPropertyItem(image, prop_id[0], prop_size + 1, &item.data);
3006                 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3007                    "%u: expected InvalidParameter, got %d\n", i, status);
3008                 status = GdipGetPropertyItem(image, prop_id[0], prop_size, &item.data);
3009                 expect(Ok, status);
3010                 ok(prop_id[0] == item.data.id,
3011                    "%u: expected property id %#x, got %#x\n", i, prop_id[0], item.data.id);
3012             }
3013         }
3014
3015         GdipDisposeImage(image);
3016     }
3017 }
3018
3019 #define IFD_BYTE      1
3020 #define IFD_ASCII     2
3021 #define IFD_SHORT     3
3022 #define IFD_LONG      4
3023 #define IFD_RATIONAL  5
3024 #define IFD_SBYTE     6
3025 #define IFD_UNDEFINED 7
3026 #define IFD_SSHORT    8
3027 #define IFD_SLONG     9
3028 #define IFD_SRATIONAL 10
3029 #define IFD_FLOAT     11
3030 #define IFD_DOUBLE    12
3031
3032 #ifndef PropertyTagTypeSByte
3033 #define PropertyTagTypeSByte  6
3034 #define PropertyTagTypeSShort 8
3035 #define PropertyTagTypeFloat  11
3036 #define PropertyTagTypeDouble 12
3037 #endif
3038
3039 static UINT documented_type(UINT type)
3040 {
3041     switch (type)
3042     {
3043     case PropertyTagTypeSByte: return PropertyTagTypeByte;
3044     case PropertyTagTypeSShort: return PropertyTagTypeShort;
3045     case PropertyTagTypeFloat: return PropertyTagTypeUndefined;
3046     case PropertyTagTypeDouble: return PropertyTagTypeUndefined;
3047     default: return type;
3048     }
3049 }
3050
3051 #include "pshpack2.h"
3052 struct IFD_entry
3053 {
3054     SHORT id;
3055     SHORT type;
3056     ULONG count;
3057     LONG  value;
3058 };
3059
3060 struct IFD_rational
3061 {
3062     LONG numerator;
3063     LONG denominator;
3064 };
3065
3066 static const struct tiff_data
3067 {
3068     USHORT byte_order;
3069     USHORT version;
3070     ULONG  dir_offset;
3071     USHORT number_of_entries;
3072     struct IFD_entry entry[40];
3073     ULONG next_IFD;
3074     struct IFD_rational xres;
3075     DOUBLE double_val;
3076     struct IFD_rational srational_val;
3077     char string[14];
3078     SHORT short_val[4];
3079     LONG long_val[2];
3080     FLOAT float_val[2];
3081     struct IFD_rational rational[3];
3082     BYTE pixel_data[4];
3083 } TIFF_data =
3084 {
3085 #ifdef WORDS_BIGENDIAN
3086     'M' | 'M' << 8,
3087 #else
3088     'I' | 'I' << 8,
3089 #endif
3090     42,
3091     FIELD_OFFSET(struct tiff_data, number_of_entries),
3092     31,
3093     {
3094         { 0xff,  IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
3095         { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
3096         { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
3097         { 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */
3098         { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
3099         { 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
3100         { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_data, pixel_data) }, /* STRIPOFFSETS */
3101         { 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
3102         { 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
3103         { 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
3104         { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_data, xres) },
3105         { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_data, xres) },
3106         { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
3107         { 0xf001, IFD_BYTE, 1, 0x11223344 },
3108         { 0xf002, IFD_BYTE, 4, 0x11223344 },
3109         { 0xf003, IFD_SBYTE, 1, 0x11223344 },
3110         { 0xf004, IFD_SSHORT, 1, 0x11223344 },
3111         { 0xf005, IFD_SSHORT, 2, 0x11223344 },
3112         { 0xf006, IFD_SLONG, 1, 0x11223344 },
3113         { 0xf007, IFD_FLOAT, 1, 0x11223344 },
3114         { 0xf008, IFD_DOUBLE, 1, FIELD_OFFSET(struct tiff_data, double_val) },
3115         { 0xf009, IFD_SRATIONAL, 1, FIELD_OFFSET(struct tiff_data, srational_val) },
3116         { 0xf00a, IFD_BYTE, 13, FIELD_OFFSET(struct tiff_data, string) },
3117         { 0xf00b, IFD_SSHORT, 4, FIELD_OFFSET(struct tiff_data, short_val) },
3118         { 0xf00c, IFD_SLONG, 2, FIELD_OFFSET(struct tiff_data, long_val) },
3119         { 0xf00e, IFD_ASCII, 13, FIELD_OFFSET(struct tiff_data, string) },
3120         { 0xf00f, IFD_ASCII, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
3121         { 0xf010, IFD_UNDEFINED, 13, FIELD_OFFSET(struct tiff_data, string) },
3122         { 0xf011, IFD_UNDEFINED, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
3123         /* Some gdiplus versions ignore these fields.
3124         { 0xf012, IFD_BYTE, 0, 0x11223344 },
3125         { 0xf013, IFD_SHORT, 0, 0x11223344 },
3126         { 0xf014, IFD_LONG, 0, 0x11223344 },
3127         { 0xf015, IFD_FLOAT, 0, 0x11223344 },*/
3128         { 0xf016, IFD_SRATIONAL, 3, FIELD_OFFSET(struct tiff_data, rational) },
3129         /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3130         { 0xf017, IFD_FLOAT, 2, FIELD_OFFSET(struct tiff_data, float_val) },
3131     },
3132     0,
3133     { 900, 3 },
3134     1234567890.0987654321,
3135     { 0x1a2b3c4d, 0x5a6b7c8d },
3136     "Hello World!",
3137     { 0x0101, 0x0202, 0x0303, 0x0404 },
3138     { 0x11223344, 0x55667788 },
3139     { (FLOAT)1234.5678, (FLOAT)8765.4321 },
3140     { { 0x01020304, 0x05060708 }, { 0x10203040, 0x50607080 }, { 0x11223344, 0x55667788 } },
3141     { 0x11, 0x22, 0x33, 0 }
3142 };
3143 #include "poppack.h"
3144
3145 static void test_tiff_properties(void)
3146 {
3147     static const struct test_data
3148     {
3149         ULONG type, id, length;
3150         const BYTE value[24];
3151     } td[31] =
3152     {
3153         { PropertyTagTypeShort, 0xff, 2, { 0 } },
3154         { PropertyTagTypeLong, 0x100, 4, { 1 } },
3155         { PropertyTagTypeLong, 0x101, 4, { 1 } },
3156         { PropertyTagTypeShort, 0x102, 2, { 1 } },
3157         { PropertyTagTypeShort, 0x103, 2, { 1 } },
3158         { PropertyTagTypeShort, 0x106, 2, { 1 } },
3159         { PropertyTagTypeLong, 0x111, 4, { 0x44,0x02 } },
3160         { PropertyTagTypeShort, 0x115, 2, { 1 } },
3161         { PropertyTagTypeLong, 0x116, 4, { 1 } },
3162         { PropertyTagTypeLong, 0x117, 4, { 1 } },
3163         { PropertyTagTypeRational, 0x11a, 8, { 0x84,0x03,0,0,0x03 } },
3164         { PropertyTagTypeRational, 0x11b, 8, { 0x84,0x03,0,0,0x03 } },
3165         { PropertyTagTypeShort, 0x128, 2, { 2 } },
3166         { PropertyTagTypeByte, 0xf001, 1, { 0x44 } },
3167         { PropertyTagTypeByte, 0xf002, 4, { 0x44,0x33,0x22,0x11 } },
3168         { PropertyTagTypeSByte, 0xf003, 1, { 0x44 } },
3169         { PropertyTagTypeSShort, 0xf004, 2, { 0x44,0x33 } },
3170         { PropertyTagTypeSShort, 0xf005, 4, { 0x44,0x33,0x22,0x11 } },
3171         { PropertyTagTypeSLONG, 0xf006, 4, { 0x44,0x33,0x22,0x11 } },
3172         { PropertyTagTypeFloat, 0xf007, 4, { 0x44,0x33,0x22,0x11 } },
3173         { PropertyTagTypeDouble, 0xf008, 8, { 0x2c,0x52,0x86,0xb4,0x80,0x65,0xd2,0x41 } },
3174         { PropertyTagTypeSRational, 0xf009, 8, { 0x4d, 0x3c, 0x2b, 0x1a, 0x8d, 0x7c, 0x6b, 0x5a } },
3175         { PropertyTagTypeByte, 0xf00a, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3176         { PropertyTagTypeSShort, 0xf00b, 8, { 0x01,0x01,0x02,0x02,0x03,0x03,0x04,0x04 } },
3177         { PropertyTagTypeSLONG, 0xf00c, 8, { 0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3178         { PropertyTagTypeASCII, 0xf00e, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3179         { PropertyTagTypeASCII, 0xf00f, 5, { 'a','b','c','d' } },
3180         { PropertyTagTypeUndefined, 0xf010, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3181         { PropertyTagTypeUndefined, 0xf011, 4, { 'a','b','c','d' } },
3182         { PropertyTagTypeSRational, 0xf016, 24,
3183           { 0x04,0x03,0x02,0x01,0x08,0x07,0x06,0x05,
3184             0x40,0x30,0x20,0x10,0x80,0x70,0x60,0x50,
3185             0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3186         /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3187         { PropertyTagTypeFloat, 0xf017, 8, { 0x2b,0x52,0x9a,0x44,0xba,0xf5,0x08,0x46 } },
3188     };
3189     GpStatus status;
3190     GpImage *image;
3191     GUID guid;
3192     UINT dim_count, frame_count, prop_count, prop_size, i;
3193     PROPID *prop_id;
3194     PropertyItem *prop_item;
3195
3196     image = load_image((const BYTE *)&TIFF_data, sizeof(TIFF_data));
3197     if (!image)
3198     {
3199         win_skip("Failed to load TIFF image data. Might not be supported. Skipping.\n");
3200         return;
3201     }
3202
3203     status = GdipImageGetFrameDimensionsCount(image, &dim_count);
3204     expect(Ok, status);
3205     expect(1, dim_count);
3206
3207     status = GdipImageGetFrameDimensionsList(image, &guid, 1);
3208     expect(Ok, status);
3209     expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
3210
3211     frame_count = 0xdeadbeef;
3212     status = GdipImageGetFrameCount(image, &guid, &frame_count);
3213     expect(Ok, status);
3214     expect(1, frame_count);
3215
3216     prop_count = 0xdeadbeef;
3217     status = GdipGetPropertyCount(image, &prop_count);
3218     expect(Ok, status);
3219     ok(prop_count == sizeof(td)/sizeof(td[0]) ||
3220        broken(prop_count == sizeof(td)/sizeof(td[0]) - 1) /* Win7 SP0 */,
3221        "expected property count %u, got %u\n", (UINT)(sizeof(td)/sizeof(td[0])), prop_count);
3222
3223     prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
3224
3225     status = GdipGetPropertyIdList(image, prop_count, prop_id);
3226     expect(Ok, status);
3227
3228     for (i = 0; i < prop_count; i++)
3229     {
3230         status = GdipGetPropertyItemSize(image, prop_id[i], &prop_size);
3231         expect(Ok, status);
3232         if (status != Ok) break;
3233         ok(prop_size > sizeof(*prop_item), "%u: too small item length %u\n", i, prop_size);
3234
3235         prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, prop_size);
3236         status = GdipGetPropertyItem(image, prop_id[i], prop_size, prop_item);
3237         expect(Ok, status);
3238         ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
3239         ok(td[i].type == prop_item->type ||
3240            /* Win7 stopped using proper but not documented types, and it
3241               looks broken since TypeFloat and TypeDouble now reported as
3242               TypeUndefined, and signed types reported as unsigned. */
3243            broken(prop_item->type == documented_type(td[i].type)),
3244             "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
3245         ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
3246         prop_size -= sizeof(*prop_item);
3247         ok(prop_item->length == prop_size, "%u: expected length %u, got %u\n", i, prop_size, prop_item->length);
3248         ok(td[i].length == prop_item->length || broken(td[i].id == 0xf00f && td[i].length == prop_item->length+1) /* XP */,
3249            "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
3250         ok(td[i].length == prop_size || broken(td[i].id == 0xf00f && td[i].length == prop_size+1) /* XP */,
3251            "%u: expected length %u, got %u\n", i, td[i].length, prop_size);
3252         if (td[i].length == prop_item->length)
3253         {
3254             int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
3255             ok(match || broken(td[i].length <= 4 && !match), "%u: data mismatch\n", i);
3256             if (!match)
3257             {
3258                 UINT j;
3259                 BYTE *data = prop_item->value;
3260                 trace("id %#x:", prop_item->id);
3261                 for (j = 0; j < prop_item->length; j++)
3262                     trace(" %02x", data[j]);
3263                 trace("\n");
3264             }
3265         }
3266         HeapFree(GetProcessHeap(), 0, prop_item);
3267     }
3268
3269     HeapFree(GetProcessHeap(), 0, prop_id);
3270
3271     GdipDisposeImage(image);
3272 }
3273
3274 static void test_GdipGetAllPropertyItems(void)
3275 {
3276     static const struct test_data
3277     {
3278         ULONG type, id, length;
3279         BYTE value[32];
3280     } td[16] =
3281     {
3282         { PropertyTagTypeLong, 0xfe, 4, { 0 } },
3283         { PropertyTagTypeShort, 0x100, 2, { 1 } },
3284         { PropertyTagTypeShort, 0x101, 2, { 1 } },
3285         { PropertyTagTypeShort, 0x102, 6, { 8,0,8,0,8,0 } },
3286         { PropertyTagTypeShort, 0x103, 2, { 1 } },
3287         { PropertyTagTypeShort, 0x106, 2, { 2,0 } },
3288         { PropertyTagTypeASCII, 0x10d, 27, "/home/meh/Desktop/test.tif" },
3289         { PropertyTagTypeLong, 0x111, 4, { 8,0,0,0 } },
3290         { PropertyTagTypeShort, 0x112, 2, { 1 } },
3291         { PropertyTagTypeShort, 0x115, 2, { 3,0 } },
3292         { PropertyTagTypeShort, 0x116, 2, { 0x40,0 } },
3293         { PropertyTagTypeLong, 0x117, 4, { 3,0,0,0 } },
3294         { PropertyTagTypeRational, 0x11a, 8, { 0,0,0,72,0,0,0,1 } },
3295         { PropertyTagTypeRational, 0x11b, 8, { 0,0,0,72,0,0,0,1 } },
3296         { PropertyTagTypeShort, 0x11c, 2, { 1 } },
3297         { PropertyTagTypeShort, 0x128, 2, { 2 } }
3298     };
3299     GpStatus status;
3300     GpImage *image;
3301     GUID guid;
3302     UINT dim_count, frame_count, prop_count, prop_size, i;
3303     UINT total_size, total_count;
3304     PROPID *prop_id;
3305     PropertyItem *prop_item;
3306     const char *item_data;
3307
3308     image = load_image(tiffimage, sizeof(tiffimage));
3309     ok(image != 0, "Failed to load TIFF image data\n");
3310     if (!image) return;
3311
3312     dim_count = 0xdeadbeef;
3313     status = GdipImageGetFrameDimensionsCount(image, &dim_count);
3314     expect(Ok, status);
3315     expect(1, dim_count);
3316
3317     status = GdipImageGetFrameDimensionsList(image, &guid, 1);
3318     expect(Ok, status);
3319     expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
3320
3321     frame_count = 0xdeadbeef;
3322     status = GdipImageGetFrameCount(image, &guid, &frame_count);
3323     expect(Ok, status);
3324     expect(1, frame_count);
3325
3326     prop_count = 0xdeadbeef;
3327     status = GdipGetPropertyCount(image, &prop_count);
3328     expect(Ok, status);
3329     ok(prop_count == sizeof(td)/sizeof(td[0]),
3330        "expected property count %u, got %u\n", (UINT)(sizeof(td)/sizeof(td[0])), prop_count);
3331
3332     prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
3333
3334     status = GdipGetPropertyIdList(image, prop_count, prop_id);
3335     expect(Ok, status);
3336
3337     prop_size = 0;
3338     for (i = 0; i < prop_count; i++)
3339     {
3340         UINT size;
3341         status = GdipGetPropertyItemSize(image, prop_id[i], &size);
3342         expect(Ok, status);
3343         if (status != Ok) break;
3344         ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
3345
3346         prop_size += size;
3347
3348         prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
3349         status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
3350         expect(Ok, status);
3351         ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
3352         ok(td[i].type == prop_item->type,
3353             "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
3354         ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
3355         size -= sizeof(*prop_item);
3356         ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
3357         ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
3358         if (td[i].length == prop_item->length)
3359         {
3360             int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
3361             ok(match, "%u: data mismatch\n", i);
3362             if (!match)
3363             {
3364                 UINT j;
3365                 BYTE *data = prop_item->value;
3366                 trace("id %#x:", prop_item->id);
3367                 for (j = 0; j < prop_item->length; j++)
3368                     trace(" %02x", data[j]);
3369                 trace("\n");
3370             }
3371         }
3372         HeapFree(GetProcessHeap(), 0, prop_item);
3373     }
3374
3375     HeapFree(GetProcessHeap(), 0, prop_id);
3376
3377     status = GdipGetPropertySize(NULL, &total_size, &total_count);
3378     expect(InvalidParameter, status);
3379     status = GdipGetPropertySize(image, &total_size, NULL);
3380     expect(InvalidParameter, status);
3381     status = GdipGetPropertySize(image, NULL, &total_count);
3382     expect(InvalidParameter, status);
3383     status = GdipGetPropertySize(image, NULL, NULL);
3384     expect(InvalidParameter, status);
3385     total_size = 0xdeadbeef;
3386     total_count = 0xdeadbeef;
3387     status = GdipGetPropertySize(image, &total_size, &total_count);
3388     expect(Ok, status);
3389     ok(prop_count == total_count,
3390        "expected total property count %u, got %u\n", prop_count, total_count);
3391     ok(prop_size == total_size,
3392        "expected total property size %u, got %u\n", prop_size, total_size);
3393
3394     prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
3395
3396     status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
3397     expect(InvalidParameter, status);
3398     status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
3399     expect(InvalidParameter, status);
3400     status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3401     expect(InvalidParameter, status);
3402     status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3403     expect(InvalidParameter, status);
3404     status = GdipGetAllPropertyItems(image, 0, 0, NULL);
3405     expect(InvalidParameter, status);
3406     status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
3407     expect(InvalidParameter, status);
3408     status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
3409     expect(Ok, status);
3410
3411     item_data = (const char *)(prop_item + prop_count);
3412     for (i = 0; i < prop_count; i++)
3413     {
3414         ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
3415            i, item_data, prop_item[i].value);
3416         ok(td[i].type == prop_item[i].type,
3417             "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
3418         ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
3419         ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
3420         if (td[i].length == prop_item[i].length)
3421         {
3422             int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
3423             ok(match, "%u: data mismatch\n", i);
3424             if (!match)
3425             {
3426                 UINT j;
3427                 BYTE *data = prop_item[i].value;
3428                 trace("id %#x:", prop_item[i].id);
3429                 for (j = 0; j < prop_item[i].length; j++)
3430                     trace(" %02x", data[j]);
3431                 trace("\n");
3432             }
3433         }
3434         item_data += prop_item[i].length;
3435     }
3436
3437     HeapFree(GetProcessHeap(), 0, prop_item);
3438
3439     GdipDisposeImage(image);
3440 }
3441
3442 static void test_tiff_palette(void)
3443 {
3444     GpStatus status;
3445     GpImage *image;
3446     PixelFormat format;
3447     INT size;
3448     struct
3449     {
3450         ColorPalette pal;
3451         ARGB entry[256];
3452     } palette;
3453     ARGB *entries = palette.pal.Entries;
3454
3455     /* 1bpp TIFF without palette */
3456     image = load_image((const BYTE *)&TIFF_data, sizeof(TIFF_data));
3457     if (!image)
3458     {
3459         win_skip("Failed to load TIFF image data. Might not be supported. Skipping.\n");
3460         return;
3461     }
3462
3463     status = GdipGetImagePixelFormat(image, &format);
3464     expect(Ok, status);
3465     ok(format == PixelFormat1bppIndexed, "expected PixelFormat1bppIndexed, got %#x\n", format);
3466
3467     status = GdipGetImagePaletteSize(image, &size);
3468     ok(status == Ok || broken(status == GenericError), /* XP */
3469        "GdipGetImagePaletteSize error %d\n", status);
3470     if (status == GenericError)
3471     {
3472         GdipDisposeImage(image);
3473         return;
3474     }
3475     expect(sizeof(ColorPalette) + sizeof(ARGB), size);
3476
3477     status = GdipGetImagePalette(image, &palette.pal, size);
3478     expect(Ok, status);
3479     expect(0, palette.pal.Flags);
3480     expect(2, palette.pal.Count);
3481     if (palette.pal.Count == 2)
3482     {
3483         ok(entries[0] == 0xff000000, "expected 0xff000000, got %#x\n", entries[0]);
3484         ok(entries[1] == 0xffffffff, "expected 0xffffffff, got %#x\n", entries[1]);
3485     }
3486
3487     GdipDisposeImage(image);
3488 }
3489
3490 static void test_bitmapbits(void)
3491 {
3492     /* 8 x 2 bitmap */
3493     static const BYTE pixels_24[48] =
3494     {
3495         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3496         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3497         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3498         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0
3499     };
3500     static const BYTE pixels_00[48] =
3501     {
3502         0,0,0, 0,0,0, 0,0,0, 0,0,0,
3503         0,0,0, 0,0,0, 0,0,0, 0,0,0,
3504         0,0,0, 0,0,0, 0,0,0, 0,0,0,
3505         0,0,0, 0,0,0, 0,0,0, 0,0,0
3506     };
3507     static const BYTE pixels_24_77[64] =
3508     {
3509         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3510         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3511         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3512         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3513         0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3514         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3515     };
3516     static const BYTE pixels_77[64] =
3517     {
3518         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3519         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3520         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3521         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3522         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3523         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3524         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3525         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3526     };
3527     static const BYTE pixels_8[16] =
3528     {
3529         0x01,0,0x01,0,0x01,0,0x01,0,
3530         0x01,0,0x01,0,0x01,0,0x01,0
3531     };
3532     static const BYTE pixels_8_77[64] =
3533     {
3534         0x01,0,0x01,0,0x01,0,0x01,0,
3535         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3536         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3537         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3538         0x01,0,0x01,0,0x01,0,0x01,0,
3539         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3540         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3541         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3542     };
3543     static const BYTE pixels_1_77[64] =
3544     {
3545         0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3546         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3547         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3548         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3549         0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3550         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3551         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3552         0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3553     };
3554     static const BYTE pixels_1[8] = {0xaa,0,0,0,0xaa,0,0,0};
3555     static const struct test_data
3556     {
3557         PixelFormat format;
3558         UINT bpp;
3559         ImageLockMode mode;
3560         UINT stride, size;
3561         const BYTE *pixels;
3562         const BYTE *pixels_unlocked;
3563     } td[] =
3564     {
3565         /* 0 */
3566         { PixelFormat24bppRGB, 24, 0xfff0, 24, 48, pixels_24, pixels_00 },
3567
3568         { PixelFormat24bppRGB, 24, 0, 24, 48, pixels_24, pixels_00 },
3569         { PixelFormat24bppRGB, 24, ImageLockModeRead, 24, 48, pixels_24, pixels_00 },
3570         { PixelFormat24bppRGB, 24, ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
3571         { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
3572         { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_24_77, pixels_24 },
3573         { PixelFormat24bppRGB, 24, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
3574         { PixelFormat24bppRGB, 24, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
3575         /* 8 */
3576         { PixelFormat8bppIndexed, 8, 0, 8, 16, pixels_8, pixels_24 },
3577         { PixelFormat8bppIndexed, 8, ImageLockModeRead, 8, 16, pixels_8, pixels_24 },
3578         { PixelFormat8bppIndexed, 8, ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
3579         { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
3580         { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_8_77, pixels_24 },
3581         { PixelFormat8bppIndexed, 8, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
3582         { PixelFormat8bppIndexed, 8, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
3583         /* 15 */
3584         { PixelFormat1bppIndexed, 1, 0, 4, 8, pixels_1, pixels_24 },
3585         { PixelFormat1bppIndexed, 1, ImageLockModeRead, 4, 8, pixels_1, pixels_24 },
3586         { PixelFormat1bppIndexed, 1, ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
3587         { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
3588         { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_1_77, pixels_24 },
3589         { PixelFormat1bppIndexed, 1, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
3590         { PixelFormat1bppIndexed, 1, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
3591     };
3592     BYTE buf[64];
3593     GpStatus status;
3594     GpBitmap *bitmap;
3595     UINT i;
3596     BitmapData data;
3597     struct
3598     {
3599         ColorPalette pal;
3600         ARGB entries[1];
3601     } palette;
3602     ARGB *entries = palette.pal.Entries;
3603
3604     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3605     {
3606         BYTE pixels[sizeof(pixels_24)];
3607         memcpy(pixels, pixels_24, sizeof(pixels_24));
3608         status = GdipCreateBitmapFromScan0(8, 2, 24, PixelFormat24bppRGB, pixels, &bitmap);
3609         expect(Ok, status);
3610
3611         /* associate known palette with pixel data */
3612         palette.pal.Flags = PaletteFlagsGrayScale;
3613         palette.pal.Count = 2;
3614         entries[0] = 0xff000000;
3615         entries[1] = 0xffffffff;
3616         status = GdipSetImagePalette((GpImage *)bitmap, &palette.pal);
3617         expect(Ok, status);
3618
3619         memset(&data, 0xfe, sizeof(data));
3620         if (td[i].mode & ImageLockModeUserInputBuf)
3621         {
3622             memset(buf, 0x77, sizeof(buf));
3623             data.Scan0 = buf;
3624             data.Stride = 32;
3625         }
3626         status = GdipBitmapLockBits(bitmap, NULL, td[i].mode, td[i].format, &data);
3627         ok(status == Ok || broken(status == InvalidParameter) /* XP */, "%u: GdipBitmapLockBits error %d\n", i, status);
3628         if (status != Ok)
3629         {
3630             GdipDisposeImage((GpImage *)bitmap);
3631             continue;
3632         }
3633         ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
3634         ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
3635         ok(td[i].stride == data.Stride, "%u: expected %d, got %d\n", i, td[i].stride, data.Stride);
3636         ok(td[i].format == data.PixelFormat, "%u: expected %d, got %d\n", i, td[i].format, data.PixelFormat);
3637         ok(td[i].size == data.Height * data.Stride, "%u: expected %d, got %d\n", i, td[i].size, data.Height * data.Stride);
3638         if (td[i].mode & ImageLockModeUserInputBuf)
3639             ok(data.Scan0 == buf, "%u: got wrong buffer\n", i);
3640         if (td[i].size == data.Height * data.Stride)
3641         {
3642             UINT j, match, width_bytes = (data.Width * td[i].bpp) / 8;
3643
3644             match = 1;
3645             for (j = 0; j < data.Height; j++)
3646             {
3647                 if (memcmp((const BYTE *)data.Scan0 + j * data.Stride, td[i].pixels + j * data.Stride, width_bytes) != 0)
3648                 {
3649                     match = 0;
3650                     break;
3651                 }
3652             }
3653             if ((td[i].mode & (ImageLockModeRead|ImageLockModeUserInputBuf)) || td[i].format == PixelFormat24bppRGB)
3654             {
3655                 ok(match,
3656                    "%u: data should match\n", i);
3657                 if (!match)
3658                 {
3659                     BYTE *bits = data.Scan0;
3660                     trace("%u: data mismatch for format %#x:", i, td[i].format);
3661                     for (j = 0; j < td[i].size; j++)
3662                         trace(" %02x", bits[j]);
3663                     trace("\n");
3664                 }
3665             }
3666             else
3667                 ok(!match, "%u: data shouldn't match\n", i);
3668
3669             memset(data.Scan0, 0, td[i].size);
3670         }
3671
3672         status = GdipBitmapUnlockBits(bitmap, &data);
3673         ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
3674
3675         memset(&data, 0xfe, sizeof(data));
3676         status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
3677         ok(status == Ok, "%u: GdipBitmapLockBits error %d\n", i, status);
3678         ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
3679         ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
3680         ok(data.Stride == 24, "%u: expected 24, got %d\n", i, data.Stride);
3681         ok(data.PixelFormat == PixelFormat24bppRGB, "%u: got wrong pixel format %d\n", i, data.PixelFormat);
3682         ok(data.Height * data.Stride == 48, "%u: expected 48, got %d\n", i, data.Height * data.Stride);
3683         if (data.Height * data.Stride == 48)
3684         {
3685             int match = memcmp(data.Scan0, td[i].pixels_unlocked, 48) == 0;
3686             ok(match, "%u: data should match\n", i);
3687             if (!match)
3688             {
3689                 UINT j;
3690                 BYTE *bits = data.Scan0;
3691                 trace("%u: data mismatch for format %#x:", i, td[i].format);
3692                 for (j = 0; j < 48; j++)
3693                     trace(" %02x", bits[j]);
3694                 trace("\n");
3695             }
3696         }
3697
3698         status = GdipBitmapUnlockBits(bitmap, &data);
3699         ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
3700
3701         status = GdipDisposeImage((GpImage *)bitmap);
3702         expect(Ok, status);
3703     }
3704 }
3705
3706 static void test_DrawImage(void)
3707 {
3708     BYTE black_1x1[4] = { 0,0,0,0 };
3709     BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
3710                            0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
3711     BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
3712                            0,0,0,0,0,0,0xff,0xff };
3713     GpStatus status;
3714     union
3715     {
3716         GpBitmap *bitmap;
3717         GpImage *image;
3718     } u1, u2;
3719     GpGraphics *graphics;
3720     int match;
3721
3722     status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
3723     expect(Ok, status);
3724     status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
3725     expect(Ok, status);
3726
3727     status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
3728     expect(Ok, status);
3729     status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
3730     expect(Ok, status);
3731     status = GdipGetImageGraphicsContext(u2.image, &graphics);
3732     expect(Ok, status);
3733     status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
3734     expect(Ok, status);
3735
3736     status = GdipDrawImageI(graphics, u1.image, 0, 0);
3737     expect(Ok, status);
3738
3739     match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
3740     ok(match, "data should match\n");
3741     if (!match)
3742     {
3743         UINT i, size = sizeof(white_2x2);
3744         BYTE *bits = white_2x2;
3745         for (i = 0; i < size; i++)
3746             trace(" %02x", bits[i]);
3747         trace("\n");
3748     }
3749
3750     status = GdipDeleteGraphics(graphics);
3751     expect(Ok, status);
3752     status = GdipDisposeImage(u1.image);
3753     expect(Ok, status);
3754     status = GdipDisposeImage(u2.image);
3755     expect(Ok, status);
3756 }
3757
3758 static void test_GdipDrawImagePointRect(void)
3759 {
3760     BYTE black_1x1[4] = { 0,0,0,0 };
3761     BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
3762                            0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
3763     BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
3764                            0,0,0,0,0,0,0xff,0xff };
3765     GpStatus status;
3766     union
3767     {
3768         GpBitmap *bitmap;
3769         GpImage *image;
3770     } u1, u2;
3771     GpGraphics *graphics;
3772     int match;
3773
3774     status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
3775     expect(Ok, status);
3776     status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
3777     expect(Ok, status);
3778
3779     status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
3780     expect(Ok, status);
3781     status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
3782     expect(Ok, status);
3783     status = GdipGetImageGraphicsContext(u2.image, &graphics);
3784     expect(Ok, status);
3785     status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
3786     expect(Ok, status);
3787
3788     status = GdipDrawImagePointRectI(graphics, u1.image, 0, 0, 0, 0, 1, 1, UnitPixel);
3789     expect(Ok, status);
3790
3791     match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
3792     ok(match, "data should match\n");
3793     if (!match)
3794     {
3795         UINT i, size = sizeof(white_2x2);
3796         BYTE *bits = white_2x2;
3797         for (i = 0; i < size; i++)
3798             trace(" %02x", bits[i]);
3799         trace("\n");
3800     }
3801
3802     status = GdipDeleteGraphics(graphics);
3803     expect(Ok, status);
3804     status = GdipDisposeImage(u1.image);
3805     expect(Ok, status);
3806     status = GdipDisposeImage(u2.image);
3807     expect(Ok, status);
3808 }
3809
3810 static void test_image_format(void)
3811 {
3812     static const PixelFormat fmt[] =
3813     {
3814         PixelFormat1bppIndexed, PixelFormat4bppIndexed, PixelFormat8bppIndexed,
3815         PixelFormat16bppGrayScale, PixelFormat16bppRGB555, PixelFormat16bppRGB565,
3816         PixelFormat16bppARGB1555, PixelFormat24bppRGB, PixelFormat32bppRGB,
3817         PixelFormat32bppARGB, PixelFormat32bppPARGB, PixelFormat48bppRGB,
3818         PixelFormat64bppARGB, PixelFormat64bppPARGB, PixelFormat32bppCMYK
3819     };
3820     GpStatus status;
3821     GpBitmap *bitmap;
3822     GpImage *thumb;
3823     HBITMAP hbitmap;
3824     BITMAP bm;
3825     PixelFormat format;
3826     BitmapData data;
3827     UINT i, ret;
3828
3829     for (i = 0; i < sizeof(fmt)/sizeof(fmt[0]); i++)
3830     {
3831         status = GdipCreateBitmapFromScan0(1, 1, 0, fmt[i], NULL, &bitmap);
3832         ok(status == Ok || broken(status == InvalidParameter) /* before win7 */,
3833            "GdipCreateBitmapFromScan0 error %d\n", status);
3834         if (status != Ok) continue;
3835
3836         status = GdipGetImagePixelFormat((GpImage *)bitmap, &format);
3837         expect(Ok, status);
3838         expect(fmt[i], format);
3839
3840         status = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
3841         if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
3842             todo_wine expect(InvalidParameter, status);
3843         else
3844         {
3845             expect(Ok, status);
3846             ret = GetObjectW(hbitmap, sizeof(bm), &bm);
3847             expect(sizeof(bm), ret);
3848             expect(0, bm.bmType);
3849             expect(1, bm.bmWidth);
3850             expect(1, bm.bmHeight);
3851             expect(4, bm.bmWidthBytes);
3852             expect(1, bm.bmPlanes);
3853             expect(32, bm.bmBitsPixel);
3854             DeleteObject(hbitmap);
3855         }
3856
3857         status = GdipGetImageThumbnail((GpImage *)bitmap, 0, 0, &thumb, NULL, NULL);
3858         if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
3859             todo_wine
3860             ok(status == OutOfMemory || broken(status == InvalidParameter) /* before win7 */,
3861                "expected OutOfMemory, got %d\n", status);
3862         else
3863         {
3864             expect(Ok, status);
3865             status = GdipGetImagePixelFormat(thumb, &format);
3866             expect(Ok, status);
3867             ok(format == PixelFormat32bppPARGB || broken(format != PixelFormat32bppPARGB) /* before win7 */,
3868                "expected PixelFormat32bppPARGB, got %#x\n", format);
3869             status = GdipDisposeImage(thumb);
3870             expect(Ok, status);
3871         }
3872
3873         status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppPARGB, &data);
3874         if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
3875             todo_wine expect(InvalidParameter, status);
3876         else
3877         {
3878             expect(Ok, status);
3879             status = GdipBitmapUnlockBits(bitmap, &data);
3880             expect(Ok, status);
3881         }
3882
3883         status = GdipDisposeImage((GpImage *)bitmap);
3884         expect(Ok, status);
3885     }
3886 }
3887
3888 static void test_DrawImage_scale(void)
3889 {
3890     static const BYTE back_8x1[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
3891                                        0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3892     static const BYTE image_080[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,
3893                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3894     static const BYTE image_100[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,
3895                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3896     static const BYTE image_120[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,
3897                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3898     static const BYTE image_150[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
3899                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3900     static const BYTE image_180[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
3901                                         0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3902     static const BYTE image_200[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
3903                                         0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3904     static const BYTE image_250[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,
3905                                         0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
3906     static const BYTE image_120_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
3907                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3908     static const BYTE image_150_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
3909                                         0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
3910     static const BYTE image_200_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
3911                                         0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40 };
3912     static const BYTE image_250_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
3913                                         0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
3914     static const struct test_data
3915     {
3916         REAL scale_x;
3917         PixelOffsetMode pixel_offset_mode;
3918         const BYTE *image;
3919         BOOL todo;
3920     } td[] =
3921     {
3922         { 0.8, PixelOffsetModeNone, image_080 }, /* 0 */
3923         { 1.0, PixelOffsetModeNone, image_100 },
3924         { 1.2, PixelOffsetModeNone, image_120 },
3925         { 1.5, PixelOffsetModeNone, image_150 },
3926         { 1.8, PixelOffsetModeNone, image_180 },
3927         { 2.0, PixelOffsetModeNone, image_200 },
3928         { 2.5, PixelOffsetModeNone, image_250 },
3929
3930         { 0.8, PixelOffsetModeHighSpeed, image_080 }, /* 7 */
3931         { 1.0, PixelOffsetModeHighSpeed, image_100 },
3932         { 1.2, PixelOffsetModeHighSpeed, image_120 },
3933         { 1.5, PixelOffsetModeHighSpeed, image_150 },
3934         { 1.8, PixelOffsetModeHighSpeed, image_180 },
3935         { 2.0, PixelOffsetModeHighSpeed, image_200 },
3936         { 2.5, PixelOffsetModeHighSpeed, image_250 },
3937
3938         { 0.8, PixelOffsetModeHalf, image_080 }, /* 14 */
3939         { 1.0, PixelOffsetModeHalf, image_100 },
3940         { 1.2, PixelOffsetModeHalf, image_120_half, TRUE },
3941         { 1.5, PixelOffsetModeHalf, image_150_half, TRUE },
3942         { 1.8, PixelOffsetModeHalf, image_180 },
3943         { 2.0, PixelOffsetModeHalf, image_200_half, TRUE },
3944         { 2.5, PixelOffsetModeHalf, image_250_half, TRUE },
3945
3946         { 0.8, PixelOffsetModeHighQuality, image_080 }, /* 21 */
3947         { 1.0, PixelOffsetModeHighQuality, image_100 },
3948         { 1.2, PixelOffsetModeHighQuality, image_120_half, TRUE },
3949         { 1.5, PixelOffsetModeHighQuality, image_150_half, TRUE },
3950         { 1.8, PixelOffsetModeHighQuality, image_180 },
3951         { 2.0, PixelOffsetModeHighQuality, image_200_half, TRUE },
3952         { 2.5, PixelOffsetModeHighQuality, image_250_half, TRUE },
3953     };
3954     BYTE src_2x1[6] = { 0x80,0x80,0x80,0x80,0x80,0x80 };
3955     BYTE dst_8x1[24];
3956     GpStatus status;
3957     union
3958     {
3959         GpBitmap *bitmap;
3960         GpImage *image;
3961     } u1, u2;
3962     GpGraphics *graphics;
3963     GpMatrix *matrix;
3964     int i, match;
3965
3966     status = GdipCreateBitmapFromScan0(2, 1, 4, PixelFormat24bppRGB, src_2x1, &u1.bitmap);
3967     expect(Ok, status);
3968     status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
3969     expect(Ok, status);
3970
3971     status = GdipCreateBitmapFromScan0(8, 1, 24, PixelFormat24bppRGB, dst_8x1, &u2.bitmap);
3972     expect(Ok, status);
3973     status = GdipBitmapSetResolution(u2.bitmap, 100.0, 100.0);
3974     expect(Ok, status);
3975     status = GdipGetImageGraphicsContext(u2.image, &graphics);
3976     expect(Ok, status);
3977     status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
3978     expect(Ok, status);
3979
3980     for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3981     {
3982         status = GdipSetPixelOffsetMode(graphics, td[i].pixel_offset_mode);
3983         expect(Ok, status);
3984
3985         status = GdipCreateMatrix2(td[i].scale_x, 0.0, 0.0, 1.0, 0.0, 0.0, &matrix);
3986         expect(Ok, status);
3987         status = GdipSetWorldTransform(graphics, matrix);
3988         expect(Ok, status);
3989         GdipDeleteMatrix(matrix);
3990
3991         memcpy(dst_8x1, back_8x1, sizeof(dst_8x1));
3992         status = GdipDrawImageI(graphics, u1.image, 1, 0);
3993         expect(Ok, status);
3994
3995         match = memcmp(dst_8x1, td[i].image, sizeof(dst_8x1)) == 0;
3996         if (!match && td[i].todo)
3997         todo_wine ok(match, "%d: data should match\n", i);
3998         else
3999         ok(match, "%d: data should match\n", i);
4000         if (!match)
4001         {
4002             UINT i, size = sizeof(dst_8x1);
4003             const BYTE *bits = dst_8x1;
4004             for (i = 0; i < size; i++)
4005                 trace(" %02x", bits[i]);
4006             trace("\n");
4007         }
4008     }
4009
4010     status = GdipDeleteGraphics(graphics);
4011     expect(Ok, status);
4012     status = GdipDisposeImage(u1.image);
4013     expect(Ok, status);
4014     status = GdipDisposeImage(u2.image);
4015     expect(Ok, status);
4016 }
4017
4018 static const BYTE animatedgif[] = {
4019 'G','I','F','8','9','a',0x01,0x00,0x01,0x00,0xA1,0x02,0x00,
4020 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
4021 /*0x21,0xFF,0x0B,'A','N','I','M','E','X','T','S','1','.','0',*/
4022 0x21,0xFF,0x0B,'N','E','T','S','C','A','P','E','2','.','0',
4023 0x03,0x01,0x05,0x00,0x00,
4024 0x21,0xFE,0x0C,'H','e','l','l','o',' ','W','o','r','l','d','!',0x00,
4025 0x21,0x01,0x0D,'a','n','i','m','a','t','i','o','n','.','g','i','f',0x00,
4026 0x21,0xF9,0x04,0xff,0x0A,0x00,0x08,0x00,
4027 0x2C,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,
4028 0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,
4029 0x02,0x02,0x4C,0x01,0x00,
4030 0x21,0xFE,0x08,'i','m','a','g','e',' ','#','1',0x00,
4031 0x21,0x01,0x0C,'p','l','a','i','n','t','e','x','t',' ','#','1',0x00,
4032 0x21,0xF9,0x04,0x00,0x14,0x00,0x01,0x00,
4033 0x2C,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,
4034 0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,
4035 0x02,0x02,0x44,0x01,0x00,
4036 0x21,0xFE,0x08,'i','m','a','g','e',' ','#','2',0x00,
4037 0x21,0x01,0x0C,'p','l','a','i','n','t','e','x','t',' ','#','2',0x00,0x3B
4038 };
4039
4040 static void test_gif_properties(void)
4041 {
4042     static const struct test_data
4043     {
4044         ULONG type, id, length;
4045         const BYTE value[13];
4046     } td[] =
4047     {
4048         { PropertyTagTypeLong, PropertyTagFrameDelay, 8, { 10,0,0,0,20,0,0,0 } },
4049         { PropertyTagTypeASCII, PropertyTagExifUserComment, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
4050         { PropertyTagTypeShort, PropertyTagLoopCount, 2, { 5,0 } },
4051         { PropertyTagTypeByte, PropertyTagGlobalPalette, 12, { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c } },
4052         { PropertyTagTypeByte, PropertyTagIndexBackground, 1, { 2 } },
4053         { PropertyTagTypeByte, PropertyTagIndexTransparent, 1, { 8 } }
4054     };
4055     GpStatus status;
4056     GpImage *image;
4057     GUID guid;
4058     UINT dim_count, frame_count, prop_count, prop_size, i;
4059     UINT total_size, total_count;
4060     PROPID *prop_id;
4061     PropertyItem *prop_item;
4062     const char *item_data;
4063
4064     image = load_image(animatedgif, sizeof(animatedgif));
4065     if (!image) /* XP fails to load this GIF image */
4066     {
4067         trace("Failed to load GIF image data\n");
4068         return;
4069     }
4070
4071     status = GdipImageGetFrameDimensionsCount(image, &dim_count);
4072     expect(Ok, status);
4073     expect(1, dim_count);
4074
4075     status = GdipImageGetFrameDimensionsList(image, &guid, 1);
4076     expect(Ok, status);
4077     expect_guid(&FrameDimensionTime, &guid, __LINE__, FALSE);
4078
4079     status = GdipImageGetFrameCount(image, &guid, &frame_count);
4080     expect(Ok, status);
4081     expect(2, frame_count);
4082
4083     status = GdipImageSelectActiveFrame(image, &guid, 1);
4084     expect(Ok, status);
4085
4086     status = GdipGetPropertyCount(image, &prop_count);
4087     expect(Ok, status);
4088     ok(prop_count == sizeof(td)/sizeof(td[0]) || broken(prop_count == 1) /* before win7 */,
4089        "expected property count %u, got %u\n", (UINT)(sizeof(td)/sizeof(td[0])), prop_count);
4090
4091     if (prop_count != sizeof(td)/sizeof(td[0]))
4092     {
4093         GdipDisposeImage(image);
4094         return;
4095     }
4096
4097     prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
4098
4099     status = GdipGetPropertyIdList(image, prop_count, prop_id);
4100     expect(Ok, status);
4101
4102     prop_size = 0;
4103     for (i = 0; i < prop_count; i++)
4104     {
4105         UINT size;
4106         status = GdipGetPropertyItemSize(image, prop_id[i], &size);
4107         expect(Ok, status);
4108         if (status != Ok) break;
4109         ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
4110
4111         prop_size += size;
4112
4113         prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
4114         status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
4115         expect(Ok, status);
4116         ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
4117         ok(td[i].type == prop_item->type,
4118             "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
4119         ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
4120         size -= sizeof(*prop_item);
4121         ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
4122         ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
4123         if (td[i].length == prop_item->length)
4124         {
4125             int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
4126             ok(match, "%u: data mismatch\n", i);
4127             if (!match)
4128             {
4129                 UINT j;
4130                 BYTE *data = prop_item->value;
4131                 trace("id %#x:", prop_item->id);
4132                 for (j = 0; j < prop_item->length; j++)
4133                     trace(" %02x", data[j]);
4134                 trace("\n");
4135             }
4136         }
4137         HeapFree(GetProcessHeap(), 0, prop_item);
4138     }
4139
4140     HeapFree(GetProcessHeap(), 0, prop_id);
4141
4142     status = GdipGetPropertySize(NULL, &total_size, &total_count);
4143     expect(InvalidParameter, status);
4144     status = GdipGetPropertySize(image, &total_size, NULL);
4145     expect(InvalidParameter, status);
4146     status = GdipGetPropertySize(image, NULL, &total_count);
4147     expect(InvalidParameter, status);
4148     status = GdipGetPropertySize(image, NULL, NULL);
4149     expect(InvalidParameter, status);
4150     total_size = 0xdeadbeef;
4151     total_count = 0xdeadbeef;
4152     status = GdipGetPropertySize(image, &total_size, &total_count);
4153     expect(Ok, status);
4154     ok(prop_count == total_count,
4155        "expected total property count %u, got %u\n", prop_count, total_count);
4156     ok(prop_size == total_size,
4157        "expected total property size %u, got %u\n", prop_size, total_size);
4158
4159     prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
4160
4161     status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
4162     expect(InvalidParameter, status);
4163     status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
4164     expect(InvalidParameter, status);
4165     status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
4166     expect(InvalidParameter, status);
4167     status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
4168     expect(InvalidParameter, status);
4169     status = GdipGetAllPropertyItems(image, 0, 0, NULL);
4170     expect(InvalidParameter, status);
4171     status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
4172     expect(InvalidParameter, status);
4173     status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
4174     expect(Ok, status);
4175
4176     item_data = (const char *)(prop_item + prop_count);
4177     for (i = 0; i < prop_count; i++)
4178     {
4179         ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
4180            i, item_data, prop_item[i].value);
4181         ok(td[i].type == prop_item[i].type,
4182             "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
4183         ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
4184         ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
4185         if (td[i].length == prop_item[i].length)
4186         {
4187             int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
4188             ok(match, "%u: data mismatch\n", i);
4189             if (!match)
4190             {
4191                 UINT j;
4192                 BYTE *data = prop_item[i].value;
4193                 trace("id %#x:", prop_item[i].id);
4194                 for (j = 0; j < prop_item[i].length; j++)
4195                     trace(" %02x", data[j]);
4196                 trace("\n");
4197             }
4198         }
4199         item_data += prop_item[i].length;
4200     }
4201
4202     HeapFree(GetProcessHeap(), 0, prop_item);
4203
4204     GdipDisposeImage(image);
4205 }
4206
4207 static void test_ARGB_conversion(void)
4208 {
4209     BYTE argb[8] = { 0x11,0x22,0x33,0x80, 0xff,0xff,0xff,0 };
4210     BYTE pargb[8] = { 0x09,0x11,0x1a,0x80, 0,0,0,0 };
4211     BYTE rgb32_xp[8] = { 0x11,0x22,0x33,0xff, 0xff,0xff,0xff,0xff };
4212     BYTE rgb24[6] = { 0x11,0x22,0x33, 0xff,0xff,0xff };
4213     BYTE *bits;
4214     GpBitmap *bitmap;
4215     BitmapData data;
4216     GpStatus status;
4217     int match;
4218
4219     status = GdipCreateBitmapFromScan0(2, 1, 8, PixelFormat32bppARGB, argb, &bitmap);
4220     expect(Ok, status);
4221
4222     status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppPARGB, &data);
4223     expect(Ok, status);
4224     ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4225     ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4226     ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4227     ok(data.PixelFormat == PixelFormat32bppPARGB, "expected PixelFormat32bppPARGB, got %d\n", data.PixelFormat);
4228     match = !memcmp(data.Scan0, pargb, sizeof(pargb));
4229     ok(match, "bits don't match\n");
4230     if (!match)
4231     {
4232         bits = data.Scan0;
4233         trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppPARGB,
4234                bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4235     }
4236     status = GdipBitmapUnlockBits(bitmap, &data);
4237     expect(Ok, status);
4238
4239     status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppRGB, &data);
4240     expect(Ok, status);
4241     ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4242     ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4243     ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4244     ok(data.PixelFormat == PixelFormat32bppRGB, "expected PixelFormat32bppRGB, got %d\n", data.PixelFormat);
4245     match = !memcmp(data.Scan0, argb, sizeof(argb)) ||
4246             !memcmp(data.Scan0, rgb32_xp, sizeof(rgb32_xp));
4247     ok(match, "bits don't match\n");
4248     if (!match)
4249     {
4250         bits = data.Scan0;
4251         trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppRGB,
4252                bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4253     }
4254     status = GdipBitmapUnlockBits(bitmap, &data);
4255     expect(Ok, status);
4256
4257     status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
4258     expect(Ok, status);
4259     ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4260     ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4261     ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4262     ok(data.PixelFormat == PixelFormat24bppRGB, "expected PixelFormat24bppRGB, got %d\n", data.PixelFormat);
4263     match = !memcmp(data.Scan0, rgb24, sizeof(rgb24));
4264     ok(match, "bits don't match\n");
4265     if (!match)
4266     {
4267         bits = data.Scan0;
4268         trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat24bppRGB,
4269                bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4270     }
4271     status = GdipBitmapUnlockBits(bitmap, &data);
4272     expect(Ok, status);
4273
4274     GdipDisposeImage((GpImage *)bitmap);
4275 }
4276
4277
4278 static void test_CloneBitmapArea(void)
4279 {
4280     GpStatus status;
4281     GpBitmap *bitmap, *copy;
4282     BitmapData data, data2;
4283
4284     status = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat24bppRGB, NULL, &bitmap);
4285     expect(Ok, status);
4286
4287     status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead | ImageLockModeWrite, PixelFormat24bppRGB, &data);
4288     expect(Ok, status);
4289
4290     status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data2);
4291     expect(WrongState, status);
4292
4293     status = GdipCloneBitmapAreaI(0, 0, 1, 1, PixelFormat24bppRGB, bitmap, &copy);
4294     expect(Ok, status);
4295
4296     status = GdipBitmapUnlockBits(bitmap, &data);
4297     expect(Ok, status);
4298
4299     GdipDisposeImage((GpImage *)copy);
4300     GdipDisposeImage((GpImage *)bitmap);
4301 }
4302
4303 START_TEST(image)
4304 {
4305     struct GdiplusStartupInput gdiplusStartupInput;
4306     ULONG_PTR gdiplusToken;
4307
4308     gdiplusStartupInput.GdiplusVersion              = 1;
4309     gdiplusStartupInput.DebugEventCallback          = NULL;
4310     gdiplusStartupInput.SuppressBackgroundThread    = 0;
4311     gdiplusStartupInput.SuppressExternalCodecs      = 0;
4312
4313     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
4314
4315     test_CloneBitmapArea();
4316     test_ARGB_conversion();
4317     test_DrawImage_scale();
4318     test_image_format();
4319     test_DrawImage();
4320     test_GdipDrawImagePointRect();
4321     test_bitmapbits();
4322     test_tiff_palette();
4323     test_GdipGetAllPropertyItems();
4324     test_tiff_properties();
4325     test_gif_properties();
4326     test_image_properties();
4327     test_Scan0();
4328     test_FromGdiDib();
4329     test_GetImageDimension();
4330     test_GdipImageGetFrameDimensionsCount();
4331     test_LoadingImages();
4332     test_SavingImages();
4333     test_encoders();
4334     test_LockBits();
4335     test_LockBits_UserBuf();
4336     test_GdipCreateBitmapFromHBITMAP();
4337     test_GdipGetImageFlags();
4338     test_GdipCloneImage();
4339     test_testcontrol();
4340     test_fromhicon();
4341     test_getrawformat();
4342     test_loadwmf();
4343     test_createfromwmf();
4344     test_resolution();
4345     test_createhbitmap();
4346     test_getthumbnail();
4347     test_getsetpixel();
4348     test_palette();
4349     test_colormatrix();
4350     test_gamma();
4351     test_multiframegif();
4352     test_rotateflip();
4353     test_remaptable();
4354     test_colorkey();
4355     test_dispose();
4356
4357     GdiplusShutdown(gdiplusToken);
4358 }