?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Increase refcount of the source stream when loading a bitmap instead of...
[wine/multimedia.git] / dlls / gdiplus / tests / image.c
blob67d0a8b9acc64d0ef7a05284fc1e3b8f985ee770
1 /*
2 * Unit test suite for images
3 *
4 * Copyright (C) 2007 Google (Evan Stade)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22
23 #include <math.h>
24
25 #include "initguid.h"
26 #include "windows.h"
27 #include "gdiplus.h"
28 #include "wine/test.h"
29
30 #define expect(expected, got) ok((got) == (expected), "Expected %d, got %d\n", (UINT)(expected), (UINT)(got))
31 #define expectf(expected, got) ok(fabs((expected) - (got)) < 0.0001, "Expected %f, got %f\n", (expected), (got))
32
33 static BOOL color_match(ARGB c1, ARGB c2, BYTE max_diff)
34 {
35 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
36 c1 >>= 8; c2 >>= 8;
37 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
38 c1 >>= 8; c2 >>= 8;
39 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
40 c1 >>= 8; c2 >>= 8;
41 if (abs((c1 & 0xff) - (c2 & 0xff)) > max_diff) return FALSE;
42 return TRUE;
43 }
44
45 static void expect_guid(REFGUID expected, REFGUID got, int line, BOOL todo)
46 {
47 WCHAR bufferW[39];
48 char buffer[39];
49 char buffer2[39];
50
51 StringFromGUID2(got, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
52 WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
53 StringFromGUID2(expected, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
54 WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer2, sizeof(buffer2), NULL, NULL);
55 if(todo)
56 todo_wine ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
57 else
58 ok_(__FILE__, line)(IsEqualGUID(expected, got), "Expected %s, got %s\n", buffer2, buffer);
59 }
60
61 static void expect_rawformat(REFGUID expected, GpImage *img, int line, BOOL todo)
62 {
63 GUID raw;
64 GpStatus stat;
65
66 stat = GdipGetImageRawFormat(img, &raw);
67 ok_(__FILE__, line)(stat == Ok, "GdipGetImageRawFormat failed with %d\n", stat);
68 if(stat != Ok) return;
69 expect_guid(expected, &raw, line, todo);
70 }
71
72 static void test_bufferrawformat(void* buff, int size, REFGUID expected, int line, BOOL todo)
73 {
74 LPSTREAM stream;
75 HGLOBAL hglob;
76 LPBYTE data;
77 HRESULT hres;
78 GpStatus stat;
79 GpImage *img;
80
81 hglob = GlobalAlloc (0, size);
82 data = GlobalLock (hglob);
83 memcpy(data, buff, size);
84 GlobalUnlock(hglob); data = NULL;
85
86 hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
87 ok_(__FILE__, line)(hres == S_OK, "Failed to create a stream\n");
88 if(hres != S_OK) return;
89
90 stat = GdipLoadImageFromStream(stream, &img);
91 ok_(__FILE__, line)(stat == Ok, "Failed to create a Bitmap\n");
92 if(stat != Ok){
93 IStream_Release(stream);
94 return;
95 }
96
97 expect_rawformat(expected, img, line, todo);
98
99 GdipDisposeImage(img);
100 IStream_Release(stream);
101 }
102
103 static void test_Scan0(void)
104 {
105 GpBitmap *bm;
106 GpStatus stat;
107 BYTE buff[360];
108
109 bm = NULL;
110 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
111 expect(Ok, stat);
112 ok(NULL != bm, "Expected bitmap to be initialized\n");
113 if (stat == Ok)
114 GdipDisposeImage((GpImage*)bm);
115
116 bm = (GpBitmap*)0xdeadbeef;
117 stat = GdipCreateBitmapFromScan0(10, -10, 10, PixelFormat24bppRGB, NULL, &bm);
118 expect(InvalidParameter, stat);
119 ok( !bm, "expected null bitmap\n" );
120
121 bm = (GpBitmap*)0xdeadbeef;
122 stat = GdipCreateBitmapFromScan0(-10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
123 expect(InvalidParameter, stat);
124 ok( !bm, "expected null bitmap\n" );
125
126 bm = (GpBitmap*)0xdeadbeef;
127 stat = GdipCreateBitmapFromScan0(10, 0, 10, PixelFormat24bppRGB, NULL, &bm);
128 expect(InvalidParameter, stat);
129 ok( !bm, "expected null bitmap\n" );
130
131 bm = NULL;
132 stat = GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB, buff, &bm);
133 expect(Ok, stat);
134 ok(NULL != bm, "Expected bitmap to be initialized\n");
135 if (stat == Ok)
136 GdipDisposeImage((GpImage*)bm);
137
138 bm = (GpBitmap*) 0xdeadbeef;
139 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, buff, &bm);
140 expect(InvalidParameter, stat);
141 ok( !bm, "expected null bitmap\n" );
142
143 bm = (GpBitmap*)0xdeadbeef;
144 stat = GdipCreateBitmapFromScan0(10, 10, 0, PixelFormat24bppRGB, buff, &bm);
145 expect(InvalidParameter, stat);
146 ok( bm == (GpBitmap*)0xdeadbeef, "expected deadbeef bitmap\n" );
147
148 bm = NULL;
149 stat = GdipCreateBitmapFromScan0(10, 10, -8, PixelFormat24bppRGB, buff, &bm);
150 expect(Ok, stat);
151 ok(NULL != bm, "Expected bitmap to be initialized\n");
152 if (stat == Ok)
153 GdipDisposeImage((GpImage*)bm);
154
155 bm = (GpBitmap*)0xdeadbeef;
156 stat = GdipCreateBitmapFromScan0(10, 10, -10, PixelFormat24bppRGB, buff, &bm);
157 expect(InvalidParameter, stat);
158 ok( !bm, "expected null bitmap\n" );
159 }
160
161 static void test_FromGdiDib(void)
162 {
163 GpBitmap *bm;
164 GpStatus stat;
165 BYTE buff[400];
166 BYTE rbmi[sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)];
167 BITMAPINFO *bmi = (BITMAPINFO*)rbmi;
168 PixelFormat format;
169
170 bm = NULL;
171
172 memset(rbmi, 0, sizeof(rbmi));
173
174 bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
175 bmi->bmiHeader.biWidth = 10;
176 bmi->bmiHeader.biHeight = 10;
177 bmi->bmiHeader.biPlanes = 1;
178 bmi->bmiHeader.biBitCount = 32;
179 bmi->bmiHeader.biCompression = BI_RGB;
180
181 stat = GdipCreateBitmapFromGdiDib(NULL, buff, &bm);
182 expect(InvalidParameter, stat);
183
184 stat = GdipCreateBitmapFromGdiDib(bmi, NULL, &bm);
185 expect(InvalidParameter, stat);
186
187 stat = GdipCreateBitmapFromGdiDib(bmi, buff, NULL);
188 expect(InvalidParameter, stat);
189
190 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
191 expect(Ok, stat);
192 ok(NULL != bm, "Expected bitmap to be initialized\n");
193 if (stat == Ok)
194 {
195 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
196 expect(Ok, stat);
197 expect(PixelFormat32bppRGB, format);
198
199 GdipDisposeImage((GpImage*)bm);
200 }
201
202 bmi->bmiHeader.biBitCount = 24;
203 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
204 expect(Ok, stat);
205 ok(NULL != bm, "Expected bitmap to be initialized\n");
206 if (stat == Ok)
207 {
208 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
209 expect(Ok, stat);
210 expect(PixelFormat24bppRGB, format);
211
212 GdipDisposeImage((GpImage*)bm);
213 }
214
215 bmi->bmiHeader.biBitCount = 16;
216 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
217 expect(Ok, stat);
218 ok(NULL != bm, "Expected bitmap to be initialized\n");
219 if (stat == Ok)
220 {
221 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
222 expect(Ok, stat);
223 expect(PixelFormat16bppRGB555, format);
224
225 GdipDisposeImage((GpImage*)bm);
226 }
227
228 bmi->bmiHeader.biBitCount = 8;
229 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
230 expect(Ok, stat);
231 ok(NULL != bm, "Expected bitmap to be initialized\n");
232 if (stat == Ok)
233 {
234 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
235 expect(Ok, stat);
236 expect(PixelFormat8bppIndexed, format);
237
238 GdipDisposeImage((GpImage*)bm);
239 }
240
241 bmi->bmiHeader.biBitCount = 4;
242 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
243 expect(Ok, stat);
244 ok(NULL != bm, "Expected bitmap to be initialized\n");
245 if (stat == Ok)
246 {
247 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
248 expect(Ok, stat);
249 expect(PixelFormat4bppIndexed, format);
250
251 GdipDisposeImage((GpImage*)bm);
252 }
253
254 bmi->bmiHeader.biBitCount = 1;
255 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
256 expect(Ok, stat);
257 ok(NULL != bm, "Expected bitmap to be initialized\n");
258 if (stat == Ok)
259 {
260 stat = GdipGetImagePixelFormat((GpImage*)bm, &format);
261 expect(Ok, stat);
262 expect(PixelFormat1bppIndexed, format);
263
264 GdipDisposeImage((GpImage*)bm);
265 }
266
267 bmi->bmiHeader.biBitCount = 0;
268 stat = GdipCreateBitmapFromGdiDib(bmi, buff, &bm);
269 expect(InvalidParameter, stat);
270 }
271
272 static void test_GetImageDimension(void)
273 {
274 GpBitmap *bm;
275 GpStatus stat;
276 const REAL WIDTH = 10.0, HEIGHT = 20.0;
277 REAL w,h;
278
279 bm = (GpBitmap*)0xdeadbeef;
280 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
281 expect(Ok,stat);
282 ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
283 ok(NULL != bm, "Expected bitmap to not be NULL\n");
284
285 stat = GdipGetImageDimension(NULL,&w,&h);
286 expect(InvalidParameter, stat);
287
288 stat = GdipGetImageDimension((GpImage*)bm,NULL,&h);
289 expect(InvalidParameter, stat);
290
291 stat = GdipGetImageDimension((GpImage*)bm,&w,NULL);
292 expect(InvalidParameter, stat);
293
294 w = -1;
295 h = -1;
296 stat = GdipGetImageDimension((GpImage*)bm,&w,&h);
297 expect(Ok, stat);
298 expectf(WIDTH, w);
299 expectf(HEIGHT, h);
300 GdipDisposeImage((GpImage*)bm);
301 }
302
303 static void test_GdipImageGetFrameDimensionsCount(void)
304 {
305 GpBitmap *bm;
306 GpStatus stat;
307 const REAL WIDTH = 10.0, HEIGHT = 20.0;
308 UINT w;
309 GUID dimension = {0};
310 UINT count;
311 ARGB color;
312
313 bm = (GpBitmap*)0xdeadbeef;
314 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
315 expect(Ok,stat);
316 ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
317 ok(NULL != bm, "Expected bitmap to not be NULL\n");
318
319 stat = GdipImageGetFrameDimensionsCount(NULL,&w);
320 expect(InvalidParameter, stat);
321
322 stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,NULL);
323 expect(InvalidParameter, stat);
324
325 w = -1;
326 stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,&w);
327 expect(Ok, stat);
328 expect(1, w);
329
330 stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 1);
331 expect(Ok, stat);
332 expect_guid(&FrameDimensionPage, &dimension, __LINE__, FALSE);
333
334 stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 2);
335 expect(InvalidParameter, stat);
336
337 stat = GdipImageGetFrameDimensionsList((GpImage*)bm, &dimension, 0);
338 expect(InvalidParameter, stat);
339
340 stat = GdipImageGetFrameCount(NULL, &dimension, &count);
341 expect(InvalidParameter, stat);
342
343 /* WinXP crashes on this test */
344 if(0)
345 {
346 stat = GdipImageGetFrameCount((GpImage*)bm, &dimension, NULL);
347 expect(InvalidParameter, stat);
348 }
349
350 stat = GdipImageGetFrameCount((GpImage*)bm, NULL, &count);
351 expect(Ok, stat);
352
353 count = 12345;
354 stat = GdipImageGetFrameCount((GpImage*)bm, &dimension, &count);
355 expect(Ok, stat);
356 expect(1, count);
357
358 GdipBitmapSetPixel(bm, 0, 0, 0xffffffff);
359
360 stat = GdipImageSelectActiveFrame((GpImage*)bm, &dimension, 0);
361 expect(Ok, stat);
362
363 /* SelectActiveFrame has no effect on image data of memory bitmaps */
364 color = 0xdeadbeef;
365 GdipBitmapGetPixel(bm, 0, 0, &color);
366 expect(0xffffffff, color);
367
368 GdipDisposeImage((GpImage*)bm);
369 }
370
371 static void test_LoadingImages(void)
372 {
373 GpStatus stat;
374
375 stat = GdipCreateBitmapFromFile(0, 0);
376 expect(InvalidParameter, stat);
377
378 stat = GdipCreateBitmapFromFile(0, (GpBitmap**)0xdeadbeef);
379 expect(InvalidParameter, stat);
380
381 stat = GdipLoadImageFromFile(0, 0);
382 expect(InvalidParameter, stat);
383
384 stat = GdipLoadImageFromFile(0, (GpImage**)0xdeadbeef);
385 expect(InvalidParameter, stat);
386
387 stat = GdipLoadImageFromFileICM(0, 0);
388 expect(InvalidParameter, stat);
389
390 stat = GdipLoadImageFromFileICM(0, (GpImage**)0xdeadbeef);
391 expect(InvalidParameter, stat);
392 }
393
394 static void test_SavingImages(void)
395 {
396 GpStatus stat;
397 GpBitmap *bm;
398 UINT n;
399 UINT s;
400 const REAL WIDTH = 10.0, HEIGHT = 20.0;
401 REAL w, h;
402 ImageCodecInfo *codecs;
403 static const CHAR filenameA[] = "a.bmp";
404 static const WCHAR filename[] = { 'a','.','b','m','p',0 };
405
406 codecs = NULL;
407
408 stat = GdipSaveImageToFile(0, 0, 0, 0);
409 expect(InvalidParameter, stat);
410
411 bm = NULL;
412 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
413 expect(Ok, stat);
414 if (!bm)
415 return;
416
417 /* invalid params */
418 stat = GdipSaveImageToFile((GpImage*)bm, 0, 0, 0);
419 expect(InvalidParameter, stat);
420
421 stat = GdipSaveImageToFile((GpImage*)bm, filename, 0, 0);
422 expect(InvalidParameter, stat);
423
424 /* encoder tests should succeed -- already tested */
425 stat = GdipGetImageEncodersSize(&n, &s);
426 if (stat != Ok || n == 0) goto cleanup;
427
428 codecs = GdipAlloc(s);
429 if (!codecs) goto cleanup;
430
431 stat = GdipGetImageEncoders(n, s, codecs);
432 if (stat != Ok) goto cleanup;
433
434 stat = GdipSaveImageToFile((GpImage*)bm, filename, &codecs[0].Clsid, 0);
435 expect(Ok, stat);
436
437 GdipDisposeImage((GpImage*)bm);
438 bm = 0;
439
440 /* re-load and check image stats */
441 stat = GdipLoadImageFromFile(filename, (GpImage**)&bm);
442 expect(Ok, stat);
443 if (stat != Ok) goto cleanup;
444
445 stat = GdipGetImageDimension((GpImage*)bm, &w, &h);
446 if (stat != Ok) goto cleanup;
447
448 expectf(WIDTH, w);
449 expectf(HEIGHT, h);
450
451 cleanup:
452 GdipFree(codecs);
453 if (bm)
454 GdipDisposeImage((GpImage*)bm);
455 ok(DeleteFileA(filenameA), "Delete failed.\n");
456 }
457
458 static void test_encoders(void)
459 {
460 GpStatus stat;
461 UINT n;
462 UINT s;
463 ImageCodecInfo *codecs;
464 int i;
465 int bmp_found;
466
467 static const CHAR bmp_format[] = "BMP";
468
469 stat = GdipGetImageEncodersSize(&n, &s);
470 expect(stat, Ok);
471
472 codecs = GdipAlloc(s);
473 if (!codecs)
474 return;
475
476 stat = GdipGetImageEncoders(n, s, NULL);
477 expect(GenericError, stat);
478
479 stat = GdipGetImageEncoders(0, s, codecs);
480 expect(GenericError, stat);
481
482 stat = GdipGetImageEncoders(n, s-1, codecs);
483 expect(GenericError, stat);
484
485 stat = GdipGetImageEncoders(n, s+1, codecs);
486 expect(GenericError, stat);
487
488 stat = GdipGetImageEncoders(n, s, codecs);
489 expect(stat, Ok);
490
491 bmp_found = FALSE;
492 for (i = 0; i < n; i++)
493 {
494 CHAR desc[32];
495
496 WideCharToMultiByte(CP_ACP, 0, codecs[i].FormatDescription, -1,
497 desc, 32, 0, 0);
498
499 if (CompareStringA(LOCALE_SYSTEM_DEFAULT, 0,
500 desc, -1,
501 bmp_format, -1) == CSTR_EQUAL) {
502 bmp_found = TRUE;
503 break;
504 }
505 }
506 if (!bmp_found)
507 ok(FALSE, "No BMP codec found.\n");
508
509 GdipFree(codecs);
510 }
511
512 static void test_LockBits(void)
513 {
514 GpStatus stat;
515 GpBitmap *bm;
516 GpRect rect;
517 BitmapData bd;
518 const INT WIDTH = 10, HEIGHT = 20;
519 ARGB color;
520 int y;
521
522 bm = NULL;
523 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
524 expect(Ok, stat);
525
526 rect.X = 2;
527 rect.Y = 3;
528 rect.Width = 4;
529 rect.Height = 5;
530
531 stat = GdipBitmapSetPixel(bm, 2, 3, 0xffc30000);
532 expect(Ok, stat);
533
534 stat = GdipBitmapSetPixel(bm, 2, 8, 0xff480000);
535 expect(Ok, stat);
536
537 /* read-only */
538 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
539 expect(Ok, stat);
540
541 if (stat == Ok) {
542 expect(0xc3, ((BYTE*)bd.Scan0)[2]);
543 expect(0x48, ((BYTE*)bd.Scan0)[2 + bd.Stride * 5]);
544
545 ((char*)bd.Scan0)[2] = 0xff;
546
547 stat = GdipBitmapUnlockBits(bm, &bd);
548 expect(Ok, stat);
549 }
550
551 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
552 expect(Ok, stat);
553 expect(0xffff0000, color);
554
555 stat = GdipBitmapSetPixel(bm, 2, 3, 0xffc30000);
556 expect(Ok, stat);
557
558 /* read-only, with NULL rect -> whole bitmap lock */
559 stat = GdipBitmapLockBits(bm, NULL, ImageLockModeRead, PixelFormat24bppRGB, &bd);
560 expect(Ok, stat);
561 expect(bd.Width, WIDTH);
562 expect(bd.Height, HEIGHT);
563
564 if (stat == Ok) {
565 ((char*)bd.Scan0)[2 + 2*3 + 3*bd.Stride] = 0xff;
566
567 stat = GdipBitmapUnlockBits(bm, &bd);
568 expect(Ok, stat);
569 }
570
571 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
572 expect(Ok, stat);
573 expect(0xffff0000, color);
574
575 /* read-only, consecutive */
576 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
577 expect(Ok, stat);
578
579 if (stat == Ok) {
580 stat = GdipBitmapUnlockBits(bm, &bd);
581 expect(Ok, stat);
582 }
583
584 stat = GdipDisposeImage((GpImage*)bm);
585 expect(Ok, stat);
586 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
587 expect(Ok, stat);
588
589 /* read x2 */
590 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
591 expect(Ok, stat);
592 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
593 expect(WrongState, stat);
594
595 stat = GdipBitmapUnlockBits(bm, &bd);
596 expect(Ok, stat);
597
598 stat = GdipDisposeImage((GpImage*)bm);
599 expect(Ok, stat);
600 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
601 expect(Ok, stat);
602
603 stat = GdipBitmapSetPixel(bm, 2, 3, 0xffff0000);
604 expect(Ok, stat);
605
606 stat = GdipBitmapSetPixel(bm, 2, 8, 0xffc30000);
607 expect(Ok, stat);
608
609 /* write, no conversion */
610 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
611 expect(Ok, stat);
612
613 if (stat == Ok) {
614 /* all bits are readable, inside the rect or not */
615 expect(0xff, ((BYTE*)bd.Scan0)[2]);
616 expect(0xc3, ((BYTE*)bd.Scan0)[2 + bd.Stride * 5]);
617
618 stat = GdipBitmapUnlockBits(bm, &bd);
619 expect(Ok, stat);
620 }
621
622 /* read, conversion */
623 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat32bppARGB, &bd);
624 expect(Ok, stat);
625
626 if (stat == Ok) {
627 expect(0xff, ((BYTE*)bd.Scan0)[2]);
628 if (0)
629 /* Areas outside the rectangle appear to be uninitialized */
630 ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
631
632 ((BYTE*)bd.Scan0)[2] = 0xc3;
633
634 stat = GdipBitmapUnlockBits(bm, &bd);
635 expect(Ok, stat);
636 }
637
638 /* writes do not work in read mode if there was a conversion */
639 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
640 expect(Ok, stat);
641 expect(0xffff0000, color);
642
643 /* read/write, conversion */
644 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeWrite, PixelFormat32bppARGB, &bd);
645 expect(Ok, stat);
646
647 if (stat == Ok) {
648 expect(0xff, ((BYTE*)bd.Scan0)[2]);
649 ((BYTE*)bd.Scan0)[1] = 0x88;
650 if (0)
651 /* Areas outside the rectangle appear to be uninitialized */
652 ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
653
654 stat = GdipBitmapUnlockBits(bm, &bd);
655 expect(Ok, stat);
656 }
657
658 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
659 expect(Ok, stat);
660 expect(0xffff8800, color);
661
662 /* write, conversion */
663 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &bd);
664 expect(Ok, stat);
665
666 if (stat == Ok) {
667 if (0)
668 {
669 /* This is completely uninitialized. */
670 ok(0xff != ((BYTE*)bd.Scan0)[2], "original image bits are readable\n");
671 ok(0xc3 != ((BYTE*)bd.Scan0)[2 + bd.Stride * 5], "original image bits are readable\n");
672 }
673
674 /* Initialize the buffer so the unlock doesn't access undefined memory */
675 for (y=0; y<5; y++)
676 memset(((BYTE*)bd.Scan0) + bd.Stride * y, 0, 12);
677
678 ((BYTE*)bd.Scan0)[0] = 0x12;
679 ((BYTE*)bd.Scan0)[1] = 0x34;
680 ((BYTE*)bd.Scan0)[2] = 0x56;
681
682 stat = GdipBitmapUnlockBits(bm, &bd);
683 expect(Ok, stat);
684 }
685
686 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
687 expect(Ok, stat);
688 expect(0xff563412, color);
689
690 stat = GdipBitmapGetPixel(bm, 2, 8, &color);
691 expect(Ok, stat);
692 expect(0xffc30000, color);
693
694 stat = GdipDisposeImage((GpImage*)bm);
695 expect(Ok, stat);
696 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
697 expect(Ok, stat);
698
699 /* write, no modification */
700 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
701 expect(Ok, stat);
702
703 if (stat == Ok) {
704 stat = GdipBitmapUnlockBits(bm, &bd);
705 expect(Ok, stat);
706 }
707
708 /* write, consecutive */
709 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
710 expect(Ok, stat);
711
712 if (stat == Ok) {
713 stat = GdipBitmapUnlockBits(bm, &bd);
714 expect(Ok, stat);
715 }
716
717 stat = GdipDisposeImage((GpImage*)bm);
718 expect(Ok, stat);
719 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
720 expect(Ok, stat);
721
722 /* write, modify */
723 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
724 expect(Ok, stat);
725
726 if (stat == Ok) {
727 if (bd.Scan0)
728 ((char*)bd.Scan0)[2] = 0xff;
729
730 stat = GdipBitmapUnlockBits(bm, &bd);
731 expect(Ok, stat);
732 }
733
734 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
735 expect(Ok, stat);
736 expect(0xffff0000, color);
737
738 stat = GdipDisposeImage((GpImage*)bm);
739 expect(Ok, stat);
740
741 /* dispose locked */
742 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
743 expect(Ok, stat);
744 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
745 expect(Ok, stat);
746 stat = GdipDisposeImage((GpImage*)bm);
747 expect(Ok, stat);
748 }
749
750 static void test_LockBits_UserBuf(void)
751 {
752 GpStatus stat;
753 GpBitmap *bm;
754 GpRect rect;
755 BitmapData bd;
756 const INT WIDTH = 10, HEIGHT = 20;
757 DWORD bits[200];
758 ARGB color;
759
760 bm = NULL;
761 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat32bppARGB, NULL, &bm);
762 expect(Ok, stat);
763
764 memset(bits, 0xaa, sizeof(bits));
765
766 rect.X = 2;
767 rect.Y = 3;
768 rect.Width = 4;
769 rect.Height = 5;
770
771 bd.Width = 4;
772 bd.Height = 6;
773 bd.Stride = WIDTH * 4;
774 bd.PixelFormat = PixelFormat32bppARGB;
775 bd.Scan0 = &bits[2+3*WIDTH];
776 bd.Reserved = 0xaaaaaaaa;
777
778 /* read-only */
779 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
780 expect(Ok, stat);
781
782 expect(0xaaaaaaaa, bits[0]);
783 expect(0, bits[2+3*WIDTH]);
784
785 bits[2+3*WIDTH] = 0xdeadbeef;
786
787 if (stat == Ok) {
788 stat = GdipBitmapUnlockBits(bm, &bd);
789 expect(Ok, stat);
790 }
791
792 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
793 expect(Ok, stat);
794 expect(0, color);
795
796 /* write-only */
797 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
798 expect(Ok, stat);
799
800 expect(0xdeadbeef, bits[2+3*WIDTH]);
801 bits[2+3*WIDTH] = 0x12345678;
802
803 if (stat == Ok) {
804 stat = GdipBitmapUnlockBits(bm, &bd);
805 expect(Ok, stat);
806 }
807
808 stat = GdipBitmapGetPixel(bm, 2, 3, &color);
809 expect(Ok, stat);
810 expect(0x12345678, color);
811
812 bits[2+3*WIDTH] = 0;
813
814 /* read/write */
815 stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead|ImageLockModeWrite|ImageLockModeUserInputBuf, PixelFormat32bppARGB, &bd);
816 expect(Ok, stat);
817
818 expect(0x12345678, bits[2+3*WIDTH]);
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(0xdeadbeef, color);
829
830 stat = GdipDisposeImage((GpImage*)bm);
831 expect(Ok, stat);
832 }
833
834 struct BITMAPINFOWITHBITFIELDS
835 {
836 BITMAPINFOHEADER bmiHeader;
837 DWORD masks[3];
838 };
839
840 union BITMAPINFOUNION
841 {
842 BITMAPINFO bi;
843 struct BITMAPINFOWITHBITFIELDS bf;
844 };
845
846 static void test_GdipCreateBitmapFromHBITMAP(void)
847 {
848 GpBitmap* gpbm = NULL;
849 HBITMAP hbm = NULL;
850 HPALETTE hpal = NULL;
851 GpStatus stat;
852 BYTE buff[1000];
853 LOGPALETTE* LogPal = NULL;
854 REAL width, height;
855 const REAL WIDTH1 = 5;
856 const REAL HEIGHT1 = 15;
857 const REAL WIDTH2 = 10;
858 const REAL HEIGHT2 = 20;
859 HDC hdc;
860 union BITMAPINFOUNION bmi;
861 BYTE *bits;
862 PixelFormat format;
863
864 stat = GdipCreateBitmapFromHBITMAP(NULL, NULL, NULL);
865 expect(InvalidParameter, stat);
866
867 hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
868 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, NULL);
869 expect(InvalidParameter, stat);
870
871 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
872 expect(Ok, stat);
873 expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
874 expectf(WIDTH1, width);
875 expectf(HEIGHT1, height);
876 if (stat == Ok)
877 GdipDisposeImage((GpImage*)gpbm);
878 DeleteObject(hbm);
879
880 memset(buff, 0, sizeof(buff));
881 hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
882 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
883 expect(Ok, stat);
884 /* raw format */
885 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)gpbm, __LINE__, FALSE);
886
887 expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
888 expectf(WIDTH2, width);
889 expectf(HEIGHT2, height);
890 if (stat == Ok)
891 GdipDisposeImage((GpImage*)gpbm);
892 DeleteObject(hbm);
893
894 hdc = CreateCompatibleDC(0);
895 ok(hdc != NULL, "CreateCompatibleDC failed\n");
896 bmi.bi.bmiHeader.biSize = sizeof(bmi.bi.bmiHeader);
897 bmi.bi.bmiHeader.biHeight = HEIGHT1;
898 bmi.bi.bmiHeader.biWidth = WIDTH1;
899 bmi.bi.bmiHeader.biBitCount = 24;
900 bmi.bi.bmiHeader.biPlanes = 1;
901 bmi.bi.bmiHeader.biCompression = BI_RGB;
902 bmi.bi.bmiHeader.biClrUsed = 0;
903
904 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
905 ok(hbm != NULL, "CreateDIBSection failed\n");
906
907 bits[0] = 0;
908
909 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
910 expect(Ok, stat);
911 expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
912 expectf(WIDTH1, width);
913 expectf(HEIGHT1, height);
914 if (stat == Ok)
915 {
916 /* test whether writing to the bitmap affects the original */
917 stat = GdipBitmapSetPixel(gpbm, 0, 0, 0xffffffff);
918 expect(Ok, stat);
919
920 expect(0, bits[0]);
921
922 GdipDisposeImage((GpImage*)gpbm);
923 }
924
925 LogPal = GdipAlloc(sizeof(LOGPALETTE));
926 ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
927 LogPal->palVersion = 0x300;
928 LogPal->palNumEntries = 1;
929 hpal = CreatePalette(LogPal);
930 ok(hpal != NULL, "CreatePalette failed\n");
931 GdipFree(LogPal);
932
933 stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
934 expect(Ok, stat);
935
936 if (stat == Ok)
937 GdipDisposeImage((GpImage*)gpbm);
938
939 DeleteObject(hpal);
940 DeleteObject(hbm);
941
942 /* 16-bit 555 dib, rgb */
943 bmi.bi.bmiHeader.biBitCount = 16;
944 bmi.bi.bmiHeader.biCompression = BI_RGB;
945
946 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
947 ok(hbm != NULL, "CreateDIBSection failed\n");
948
949 bits[0] = 0;
950
951 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
952 expect(Ok, stat);
953
954 if (stat == Ok)
955 {
956 stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
957 expect(Ok, stat);
958 expectf(WIDTH1, width);
959 expectf(HEIGHT1, height);
960
961 stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
962 expect(Ok, stat);
963 expect(PixelFormat16bppRGB555, format);
964
965 GdipDisposeImage((GpImage*)gpbm);
966 }
967 DeleteObject(hbm);
968
969 /* 16-bit 555 dib, with bitfields */
970 bmi.bi.bmiHeader.biSize = sizeof(bmi);
971 bmi.bi.bmiHeader.biCompression = BI_BITFIELDS;
972 bmi.bf.masks[0] = 0x7c00;
973 bmi.bf.masks[1] = 0x3e0;
974 bmi.bf.masks[2] = 0x1f;
975
976 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
977 ok(hbm != NULL, "CreateDIBSection failed\n");
978
979 bits[0] = 0;
980
981 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
982 expect(Ok, stat);
983
984 if (stat == Ok)
985 {
986 stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
987 expect(Ok, stat);
988 expectf(WIDTH1, width);
989 expectf(HEIGHT1, height);
990
991 stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
992 expect(Ok, stat);
993 expect(PixelFormat16bppRGB555, format);
994
995 GdipDisposeImage((GpImage*)gpbm);
996 }
997 DeleteObject(hbm);
998
999 /* 16-bit 565 dib, with bitfields */
1000 bmi.bf.masks[0] = 0xf800;
1001 bmi.bf.masks[1] = 0x7e0;
1002 bmi.bf.masks[2] = 0x1f;
1003
1004 hbm = CreateDIBSection(hdc, &bmi.bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1005 ok(hbm != NULL, "CreateDIBSection failed\n");
1006
1007 bits[0] = 0;
1008
1009 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
1010 expect(Ok, stat);
1011
1012 if (stat == Ok)
1013 {
1014 stat = GdipGetImageDimension((GpImage*) gpbm, &width, &height);
1015 expect(Ok, stat);
1016 expectf(WIDTH1, width);
1017 expectf(HEIGHT1, height);
1018
1019 stat = GdipGetImagePixelFormat((GpImage*) gpbm, &format);
1020 expect(Ok, stat);
1021 expect(PixelFormat16bppRGB565, format);
1022
1023 GdipDisposeImage((GpImage*)gpbm);
1024 }
1025 DeleteObject(hbm);
1026
1027 DeleteDC(hdc);
1028 }
1029
1030 static void test_GdipGetImageFlags(void)
1031 {
1032 GpImage *img;
1033 GpStatus stat;
1034 UINT flags;
1035
1036 img = (GpImage*)0xdeadbeef;
1037
1038 stat = GdipGetImageFlags(NULL, NULL);
1039 expect(InvalidParameter, stat);
1040
1041 stat = GdipGetImageFlags(NULL, &flags);
1042 expect(InvalidParameter, stat);
1043
1044 stat = GdipGetImageFlags(img, NULL);
1045 expect(InvalidParameter, stat);
1046
1047 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat1bppIndexed, NULL, (GpBitmap**)&img);
1048 expect(Ok, stat);
1049 stat = GdipGetImageFlags(img, &flags);
1050 expect(Ok, stat);
1051 expect(ImageFlagsHasAlpha, flags);
1052 GdipDisposeImage(img);
1053
1054 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat4bppIndexed, NULL, (GpBitmap**)&img);
1055 expect(Ok, stat);
1056 stat = GdipGetImageFlags(img, &flags);
1057 expect(Ok, stat);
1058 expect(ImageFlagsHasAlpha, flags);
1059 GdipDisposeImage(img);
1060
1061 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat8bppIndexed, NULL, (GpBitmap**)&img);
1062 expect(Ok, stat);
1063 stat = GdipGetImageFlags(img, &flags);
1064 expect(Ok, stat);
1065 expect(ImageFlagsHasAlpha, flags);
1066 GdipDisposeImage(img);
1067
1068 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppGrayScale, NULL, (GpBitmap**)&img);
1069 expect(Ok, stat);
1070 stat = GdipGetImageFlags(img, &flags);
1071 expect(Ok, stat);
1072 expect(ImageFlagsNone, flags);
1073 GdipDisposeImage(img);
1074
1075 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB555, NULL, (GpBitmap**)&img);
1076 expect(Ok, stat);
1077 stat = GdipGetImageFlags(img, &flags);
1078 expect(Ok, stat);
1079 expect(ImageFlagsNone, flags);
1080 GdipDisposeImage(img);
1081
1082 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB565, NULL, (GpBitmap**)&img);
1083 expect(Ok, stat);
1084 stat = GdipGetImageFlags(img, &flags);
1085 expect(Ok, stat);
1086 expect(ImageFlagsNone, flags);
1087 GdipDisposeImage(img);
1088
1089 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppARGB1555, NULL, (GpBitmap**)&img);
1090 expect(Ok, stat);
1091 stat = GdipGetImageFlags(img, &flags);
1092 expect(Ok, stat);
1093 expect(ImageFlagsHasAlpha, flags);
1094 GdipDisposeImage(img);
1095
1096 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, (GpBitmap**)&img);
1097 expect(Ok, stat);
1098 stat = GdipGetImageFlags(img, &flags);
1099 expect(Ok, stat);
1100 expect(ImageFlagsNone, flags);
1101 GdipDisposeImage(img);
1102
1103 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppRGB, NULL, (GpBitmap**)&img);
1104 expect(Ok, stat);
1105 stat = GdipGetImageFlags(img, &flags);
1106 expect(Ok, stat);
1107 expect(ImageFlagsNone, flags);
1108 GdipDisposeImage(img);
1109
1110 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppARGB, NULL, (GpBitmap**)&img);
1111 expect(Ok, stat);
1112 stat = GdipGetImageFlags(img, &flags);
1113 expect(Ok, stat);
1114 expect(ImageFlagsHasAlpha, flags);
1115 GdipDisposeImage(img);
1116
1117 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppPARGB, NULL, (GpBitmap**)&img);
1118 expect(Ok, stat);
1119 stat = GdipGetImageFlags(img, &flags);
1120 expect(Ok, stat);
1121 expect(ImageFlagsHasAlpha, flags);
1122 GdipDisposeImage(img);
1123
1124 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat48bppRGB, NULL, (GpBitmap**)&img);
1125 expect(Ok, stat);
1126 if (stat == Ok)
1127 {
1128 stat = GdipGetImageFlags(img, &flags);
1129 expect(Ok, stat);
1130 expect(ImageFlagsNone, flags);
1131 GdipDisposeImage(img);
1132 }
1133
1134 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppARGB, NULL, (GpBitmap**)&img);
1135 expect(Ok, stat);
1136 if (stat == Ok)
1137 {
1138 expect(Ok, stat);
1139 stat = GdipGetImageFlags(img, &flags);
1140 expect(Ok, stat);
1141 expect(ImageFlagsHasAlpha, flags);
1142 GdipDisposeImage(img);
1143 }
1144
1145 stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppPARGB, NULL, (GpBitmap**)&img);
1146 expect(Ok, stat);
1147 if (stat == Ok)
1148 {
1149 expect(Ok, stat);
1150 stat = GdipGetImageFlags(img, &flags);
1151 expect(Ok, stat);
1152 expect(ImageFlagsHasAlpha, flags);
1153 GdipDisposeImage(img);
1154 }
1155 }
1156
1157 static void test_GdipCloneImage(void)
1158 {
1159 GpStatus stat;
1160 GpRectF rectF;
1161 GpUnit unit;
1162 GpBitmap *bm;
1163 GpImage *image_src, *image_dest = NULL;
1164 const INT WIDTH = 10, HEIGHT = 20;
1165
1166 /* Create an image, clone it, delete the original, make sure the copy works */
1167 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
1168 expect(Ok, stat);
1169 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bm, __LINE__, FALSE);
1170
1171 image_src = ((GpImage*)bm);
1172 stat = GdipCloneImage(image_src, &image_dest);
1173 expect(Ok, stat);
1174 expect_rawformat(&ImageFormatMemoryBMP, image_dest, __LINE__, FALSE);
1175
1176 stat = GdipDisposeImage((GpImage*)bm);
1177 expect(Ok, stat);
1178 stat = GdipGetImageBounds(image_dest, &rectF, &unit);
1179 expect(Ok, stat);
1180
1181 /* Treat FP values carefully */
1182 expectf((REAL)WIDTH, rectF.Width);
1183 expectf((REAL)HEIGHT, rectF.Height);
1184
1185 stat = GdipDisposeImage(image_dest);
1186 expect(Ok, stat);
1187 }
1188
1189 static void test_testcontrol(void)
1190 {
1191 GpStatus stat;
1192 DWORD param;
1193
1194 param = 0;
1195 stat = GdipTestControl(TestControlGetBuildNumber, &param);
1196 expect(Ok, stat);
1197 ok(param != 0, "Build number expected, got %u\n", param);
1198 }
1199
1200 static void test_fromhicon(void)
1201 {
1202 static const BYTE bmp_bits[1024];
1203 HBITMAP hbmMask, hbmColor;
1204 ICONINFO info;
1205 HICON hIcon;
1206 GpStatus stat;
1207 GpBitmap *bitmap = NULL;
1208 UINT dim;
1209 ImageType type;
1210 PixelFormat format;
1211
1212 /* NULL */
1213 stat = GdipCreateBitmapFromHICON(NULL, NULL);
1214 expect(InvalidParameter, stat);
1215 stat = GdipCreateBitmapFromHICON(NULL, &bitmap);
1216 expect(InvalidParameter, stat);
1217
1218 /* color icon 1 bit */
1219 hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
1220 ok(hbmMask != 0, "CreateBitmap failed\n");
1221 hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
1222 ok(hbmColor != 0, "CreateBitmap failed\n");
1223 info.fIcon = TRUE;
1224 info.xHotspot = 8;
1225 info.yHotspot = 8;
1226 info.hbmMask = hbmMask;
1227 info.hbmColor = hbmColor;
1228 hIcon = CreateIconIndirect(&info);
1229 ok(hIcon != 0, "CreateIconIndirect failed\n");
1230 DeleteObject(hbmMask);
1231 DeleteObject(hbmColor);
1232
1233 stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
1234 ok(stat == Ok ||
1235 broken(stat == InvalidParameter), /* Win98 */
1236 "Expected Ok, got %.8x\n", stat);
1237 if(stat == Ok){
1238 /* check attributes */
1239 stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
1240 expect(Ok, stat);
1241 expect(16, dim);
1242 stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
1243 expect(Ok, stat);
1244 expect(16, dim);
1245 stat = GdipGetImageType((GpImage*)bitmap, &type);
1246 expect(Ok, stat);
1247 expect(ImageTypeBitmap, type);
1248 stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
1249 expect(Ok, stat);
1250 expect(PixelFormat32bppARGB, format);
1251 /* raw format */
1252 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1253 GdipDisposeImage((GpImage*)bitmap);
1254 }
1255 DestroyIcon(hIcon);
1256
1257 /* color icon 8 bpp */
1258 hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
1259 ok(hbmMask != 0, "CreateBitmap failed\n");
1260 hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
1261 ok(hbmColor != 0, "CreateBitmap failed\n");
1262 info.fIcon = TRUE;
1263 info.xHotspot = 8;
1264 info.yHotspot = 8;
1265 info.hbmMask = hbmMask;
1266 info.hbmColor = hbmColor;
1267 hIcon = CreateIconIndirect(&info);
1268 ok(hIcon != 0, "CreateIconIndirect failed\n");
1269 DeleteObject(hbmMask);
1270 DeleteObject(hbmColor);
1271
1272 stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
1273 expect(Ok, stat);
1274 if(stat == Ok){
1275 /* check attributes */
1276 stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
1277 expect(Ok, stat);
1278 expect(16, dim);
1279 stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
1280 expect(Ok, stat);
1281 expect(16, dim);
1282 stat = GdipGetImageType((GpImage*)bitmap, &type);
1283 expect(Ok, stat);
1284 expect(ImageTypeBitmap, type);
1285 stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
1286 expect(Ok, stat);
1287 expect(PixelFormat32bppARGB, format);
1288 /* raw format */
1289 expect_rawformat(&ImageFormatMemoryBMP, (GpImage*)bitmap, __LINE__, FALSE);
1290 GdipDisposeImage((GpImage*)bitmap);
1291 }
1292 DestroyIcon(hIcon);
1293 }
1294
1295 /* 1x1 pixel png */
1296 static const unsigned char pngimage[285] = {
1297 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
1298 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
1299 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
1300 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
1301 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
1302 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
1303 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
1304 };
1305 /* 1x1 pixel gif */
1306 static const unsigned char gifimage[35] = {
1307 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
1308 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
1309 0x01,0x00,0x3b
1310 };
1311 /* 1x1 pixel bmp */
1312 static const unsigned char bmpimage[66] = {
1313 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
1314 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
1315 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
1316 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
1317 0x00,0x00
1318 };
1319 /* 1x1 pixel jpg */
1320 static const unsigned char jpgimage[285] = {
1321 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
1322 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
1323 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
1324 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
1325 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
1326 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
1327 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
1328 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1329 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1330 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
1331 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
1332 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1333 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
1334 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
1335 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1336 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
1337 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
1338 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
1339 };
1340 /* 1x1 pixel tiff */
1341 static const unsigned char tiffimage[] = {
1342 0x49,0x49,0x2a,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0xfe,0x00,
1343 0x04,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x00,0x01,0x00,
1344 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1345 0x00,0x00,0x02,0x01,0x03,0x00,0x03,0x00,0x00,0x00,0xd2,0x00,0x00,0x00,0x03,0x01,
1346 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x01,0x03,0x00,0x01,0x00,
1347 0x00,0x00,0x02,0x00,0x00,0x00,0x0d,0x01,0x02,0x00,0x1b,0x00,0x00,0x00,0xd8,0x00,
1348 0x00,0x00,0x11,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x12,0x01,
1349 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x01,0x03,0x00,0x01,0x00,
1350 0x00,0x00,0x03,0x00,0x00,0x00,0x16,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x40,0x00,
1351 0x00,0x00,0x17,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x1a,0x01,
1352 0x05,0x00,0x01,0x00,0x00,0x00,0xf4,0x00,0x00,0x00,0x1b,0x01,0x05,0x00,0x01,0x00,
1353 0x00,0x00,0xfc,0x00,0x00,0x00,0x1c,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1354 0x00,0x00,0x28,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
1355 0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x2f,0x68,0x6f,0x6d,0x65,0x2f,0x6d,0x65,
1356 0x68,0x2f,0x44,0x65,0x73,0x6b,0x74,0x6f,0x70,0x2f,0x74,0x65,0x73,0x74,0x2e,0x74,
1357 0x69,0x66,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x48,
1358 0x00,0x00,0x00,0x01
1359 };
1360 /* 320x320 twip wmf */
1361 static const unsigned char wmfimage[180] = {
1362 0xd7,0xcd,0xc6,0x9a,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0x40,0x01,0xa0,0x05,
1363 0x00,0x00,0x00,0x00,0xb1,0x52,0x01,0x00,0x09,0x00,0x00,0x03,0x4f,0x00,0x00,0x00,
1364 0x0f,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0b,0x02,0x00,0x00,
1365 0x00,0x00,0x05,0x00,0x00,0x00,0x0c,0x02,0x40,0x01,0x40,0x01,0x04,0x00,0x00,0x00,
1366 0x02,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x04,0x01,0x0d,0x00,0x08,0x00,0x00,0x00,
1367 0xfa,0x02,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
1368 0x2d,0x01,0x00,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,0x01,0x00,0x00,0x00,0x00,0x00,
1369 0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x01,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,
1370 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x02,0x00,
1371 0x07,0x00,0x00,0x00,0x1b,0x04,0x40,0x01,0x40,0x01,0x00,0x00,0x00,0x00,0x04,0x00,
1372 0x00,0x00,0xf0,0x01,0x00,0x00,0x04,0x00,0x00,0x00,0xf0,0x01,0x01,0x00,0x03,0x00,
1373 0x00,0x00,0x00,0x00
1374 };
1375 static void test_getrawformat(void)
1376 {
1377 test_bufferrawformat((void*)pngimage, sizeof(pngimage), &ImageFormatPNG, __LINE__, FALSE);
1378 test_bufferrawformat((void*)gifimage, sizeof(gifimage), &ImageFormatGIF, __LINE__, FALSE);
1379 test_bufferrawformat((void*)bmpimage, sizeof(bmpimage), &ImageFormatBMP, __LINE__, FALSE);
1380 test_bufferrawformat((void*)jpgimage, sizeof(jpgimage), &ImageFormatJPEG, __LINE__, FALSE);
1381 test_bufferrawformat((void*)tiffimage, sizeof(tiffimage), &ImageFormatTIFF, __LINE__, FALSE);
1382 test_bufferrawformat((void*)wmfimage, sizeof(wmfimage), &ImageFormatWMF, __LINE__, FALSE);
1383 }
1384
1385 static void test_loadwmf(void)
1386 {
1387 LPSTREAM stream;
1388 HGLOBAL hglob;
1389 LPBYTE data;
1390 HRESULT hres;
1391 GpStatus stat;
1392 GpImage *img;
1393 GpRectF bounds;
1394 GpUnit unit;
1395 REAL res = 12345.0;
1396 MetafileHeader header;
1397
1398 hglob = GlobalAlloc (0, sizeof(wmfimage));
1399 data = GlobalLock (hglob);
1400 memcpy(data, wmfimage, sizeof(wmfimage));
1401 GlobalUnlock(hglob); data = NULL;
1402
1403 hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
1404 ok(hres == S_OK, "Failed to create a stream\n");
1405 if(hres != S_OK) return;
1406
1407 stat = GdipLoadImageFromStream(stream, &img);
1408 ok(stat == Ok, "Failed to create a Bitmap\n");
1409 if(stat != Ok){
1410 IStream_Release(stream);
1411 return;
1412 }
1413
1414 IStream_Release(stream);
1415
1416 stat = GdipGetImageBounds(img, &bounds, &unit);
1417 expect(Ok, stat);
1418 todo_wine expect(UnitPixel, unit);
1419 expectf(0.0, bounds.X);
1420 expectf(0.0, bounds.Y);
1421 todo_wine expectf(320.0, bounds.Width);
1422 todo_wine expectf(320.0, bounds.Height);
1423
1424 stat = GdipGetImageHorizontalResolution(img, &res);
1425 expect(Ok, stat);
1426 todo_wine expectf(1440.0, res);
1427
1428 stat = GdipGetImageVerticalResolution(img, &res);
1429 expect(Ok, stat);
1430 todo_wine expectf(1440.0, res);
1431
1432 memset(&header, 0, sizeof(header));
1433 stat = GdipGetMetafileHeaderFromMetafile((GpMetafile*)img, &header);
1434 expect(Ok, stat);
1435 if (stat == Ok)
1436 {
1437 todo_wine expect(MetafileTypeWmfPlaceable, header.Type);
1438 todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
1439 todo_wine expect(0x300, header.Version);
1440 expect(0, header.EmfPlusFlags);
1441 todo_wine expectf(1440.0, header.DpiX);
1442 todo_wine expectf(1440.0, header.DpiY);
1443 expect(0, header.X);
1444 expect(0, header.Y);
1445 todo_wine expect(320, header.Width);
1446 todo_wine expect(320, header.Height);
1447 todo_wine expect(1, U(header).WmfHeader.mtType);
1448 expect(0, header.EmfPlusHeaderSize);
1449 expect(0, header.LogicalDpiX);
1450 expect(0, header.LogicalDpiY);
1451 }
1452
1453 GdipDisposeImage(img);
1454 }
1455
1456 static void test_createfromwmf(void)
1457 {
1458 HMETAFILE hwmf;
1459 GpImage *img;
1460 GpStatus stat;
1461 GpRectF bounds;
1462 GpUnit unit;
1463 REAL res = 12345.0;
1464 MetafileHeader header;
1465
1466 hwmf = SetMetaFileBitsEx(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader),
1467 wmfimage+sizeof(WmfPlaceableFileHeader));
1468 ok(hwmf != 0, "SetMetaFileBitsEx failed\n");
1469
1470 stat = GdipCreateMetafileFromWmf(hwmf, TRUE,
1471 (WmfPlaceableFileHeader*)wmfimage, (GpMetafile**)&img);
1472 expect(Ok, stat);
1473
1474 stat = GdipGetImageBounds(img, &bounds, &unit);
1475 expect(Ok, stat);
1476 expect(UnitPixel, unit);
1477 expectf(0.0, bounds.X);
1478 expectf(0.0, bounds.Y);
1479 expectf(320.0, bounds.Width);
1480 expectf(320.0, bounds.Height);
1481
1482 stat = GdipGetImageHorizontalResolution(img, &res);
1483 expect(Ok, stat);
1484 expectf(1440.0, res);
1485
1486 stat = GdipGetImageVerticalResolution(img, &res);
1487 expect(Ok, stat);
1488 expectf(1440.0, res);
1489
1490 memset(&header, 0, sizeof(header));
1491 stat = GdipGetMetafileHeaderFromMetafile((GpMetafile*)img, &header);
1492 expect(Ok, stat);
1493 if (stat == Ok)
1494 {
1495 todo_wine expect(MetafileTypeWmfPlaceable, header.Type);
1496 todo_wine expect(sizeof(wmfimage)-sizeof(WmfPlaceableFileHeader), header.Size);
1497 todo_wine expect(0x300, header.Version);
1498 expect(0, header.EmfPlusFlags);
1499 todo_wine expectf(1440.0, header.DpiX);
1500 todo_wine expectf(1440.0, header.DpiY);
1501 expect(0, header.X);
1502 expect(0, header.Y);
1503 todo_wine expect(320, header.Width);
1504 todo_wine expect(320, header.Height);
1505 todo_wine expect(1, U(header).WmfHeader.mtType);
1506 expect(0, header.EmfPlusHeaderSize);
1507 expect(0, header.LogicalDpiX);
1508 expect(0, header.LogicalDpiY);
1509 }
1510
1511 GdipDisposeImage(img);
1512 }
1513
1514 static void test_resolution(void)
1515 {
1516 GpStatus stat;
1517 GpBitmap *bitmap;
1518 REAL res=-1.0;
1519 HDC screendc;
1520 int screenxres, screenyres;
1521
1522 /* create Bitmap */
1523 stat = GdipCreateBitmapFromScan0(1, 1, 32, PixelFormat24bppRGB, NULL, &bitmap);
1524 expect(Ok, stat);
1525
1526 /* test invalid values */
1527 stat = GdipGetImageHorizontalResolution(NULL, &res);
1528 expect(InvalidParameter, stat);
1529
1530 stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, NULL);
1531 expect(InvalidParameter, stat);
1532
1533 stat = GdipGetImageVerticalResolution(NULL, &res);
1534 expect(InvalidParameter, stat);
1535
1536 stat = GdipGetImageVerticalResolution((GpImage*)bitmap, NULL);
1537 expect(InvalidParameter, stat);
1538
1539 stat = GdipBitmapSetResolution(NULL, 96.0, 96.0);
1540 expect(InvalidParameter, stat);
1541
1542 stat = GdipBitmapSetResolution(bitmap, 0.0, 0.0);
1543 expect(InvalidParameter, stat);
1544
1545 /* defaults to screen resolution */
1546 screendc = GetDC(0);
1547
1548 screenxres = GetDeviceCaps(screendc, LOGPIXELSX);
1549 screenyres = GetDeviceCaps(screendc, LOGPIXELSY);
1550
1551 ReleaseDC(0, screendc);
1552
1553 stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &res);
1554 expect(Ok, stat);
1555 expectf((REAL)screenxres, res);
1556
1557 stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &res);
1558 expect(Ok, stat);
1559 expectf((REAL)screenyres, res);
1560
1561 /* test changing the resolution */
1562 stat = GdipBitmapSetResolution(bitmap, screenxres*2.0, screenyres*3.0);
1563 expect(Ok, stat);
1564
1565 stat = GdipGetImageHorizontalResolution((GpImage*)bitmap, &res);
1566 expect(Ok, stat);
1567 expectf(screenxres*2.0, res);
1568
1569 stat = GdipGetImageVerticalResolution((GpImage*)bitmap, &res);
1570 expect(Ok, stat);
1571 expectf(screenyres*3.0, res);
1572
1573 stat = GdipDisposeImage((GpImage*)bitmap);
1574 expect(Ok, stat);
1575 }
1576
1577 static void test_createhbitmap(void)
1578 {
1579 GpStatus stat;
1580 GpBitmap *bitmap;
1581 HBITMAP hbitmap, oldhbitmap;
1582 BITMAP bm;
1583 int ret;
1584 HDC hdc;
1585 COLORREF pixel;
1586 BYTE bits[640];
1587
1588 memset(bits, 0x68, 640);
1589
1590 /* create Bitmap */
1591 stat = GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB, bits, &bitmap);
1592 expect(Ok, stat);
1593
1594 /* test NULL values */
1595 stat = GdipCreateHBITMAPFromBitmap(NULL, &hbitmap, 0);
1596 expect(InvalidParameter, stat);
1597
1598 stat = GdipCreateHBITMAPFromBitmap(bitmap, NULL, 0);
1599 expect(InvalidParameter, stat);
1600
1601 /* create HBITMAP */
1602 stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
1603 expect(Ok, stat);
1604
1605 if (stat == Ok)
1606 {
1607 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1608 expect(sizeof(BITMAP), ret);
1609
1610 expect(0, bm.bmType);
1611 expect(10, bm.bmWidth);
1612 expect(20, bm.bmHeight);
1613 expect(40, bm.bmWidthBytes);
1614 expect(1, bm.bmPlanes);
1615 expect(32, bm.bmBitsPixel);
1616 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1617
1618 if (bm.bmBits)
1619 {
1620 DWORD val = *(DWORD*)bm.bmBits;
1621 ok(val == 0xff686868, "got %x, expected 0xff686868\n", val);
1622 }
1623
1624 hdc = CreateCompatibleDC(NULL);
1625
1626 oldhbitmap = SelectObject(hdc, hbitmap);
1627 pixel = GetPixel(hdc, 5, 5);
1628 SelectObject(hdc, oldhbitmap);
1629
1630 DeleteDC(hdc);
1631
1632 expect(0x686868, pixel);
1633
1634 DeleteObject(hbitmap);
1635 }
1636
1637 stat = GdipDisposeImage((GpImage*)bitmap);
1638 expect(Ok, stat);
1639
1640 /* create alpha Bitmap */
1641 stat = GdipCreateBitmapFromScan0(8, 20, 32, PixelFormat32bppARGB, bits, &bitmap);
1642 expect(Ok, stat);
1643
1644 /* create HBITMAP */
1645 stat = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
1646 expect(Ok, stat);
1647
1648 if (stat == Ok)
1649 {
1650 ret = GetObjectA(hbitmap, sizeof(BITMAP), &bm);
1651 expect(sizeof(BITMAP), ret);
1652
1653 expect(0, bm.bmType);
1654 expect(8, bm.bmWidth);
1655 expect(20, bm.bmHeight);
1656 expect(32, bm.bmWidthBytes);
1657 expect(1, bm.bmPlanes);
1658 expect(32, bm.bmBitsPixel);
1659 ok(bm.bmBits != NULL, "got DDB, expected DIB\n");
1660
1661 if (bm.bmBits)
1662 {
1663 DWORD val = *(DWORD*)bm.bmBits;
1664 ok(val == 0x682a2a2a, "got %x, expected 0x682a2a2a\n", val);
1665 }
1666
1667 hdc = CreateCompatibleDC(NULL);
1668
1669 oldhbitmap = SelectObject(hdc, hbitmap);
1670 pixel = GetPixel(hdc, 5, 5);
1671 SelectObject(hdc, oldhbitmap);
1672
1673 DeleteDC(hdc);
1674
1675 expect(0x2a2a2a, pixel);
1676
1677 DeleteObject(hbitmap);
1678 }
1679
1680 stat = GdipDisposeImage((GpImage*)bitmap);
1681 expect(Ok, stat);
1682 }
1683
1684 static void test_getthumbnail(void)
1685 {
1686 GpStatus stat;
1687 GpImage *bitmap1, *bitmap2;
1688 UINT width, height;
1689
1690 stat = GdipGetImageThumbnail(NULL, 0, 0, &bitmap2, NULL, NULL);
1691 expect(InvalidParameter, stat);
1692
1693 stat = GdipCreateBitmapFromScan0(128, 128, 0, PixelFormat32bppRGB, NULL, (GpBitmap**)&bitmap1);
1694 expect(Ok, stat);
1695
1696 stat = GdipGetImageThumbnail(bitmap1, 0, 0, NULL, NULL, NULL);
1697 expect(InvalidParameter, stat);
1698
1699 stat = GdipGetImageThumbnail(bitmap1, 0, 0, &bitmap2, NULL, NULL);
1700 expect(Ok, stat);
1701
1702 if (stat == Ok)
1703 {
1704 stat = GdipGetImageWidth(bitmap2, &width);
1705 expect(Ok, stat);
1706 expect(120, width);
1707
1708 stat = GdipGetImageHeight(bitmap2, &height);
1709 expect(Ok, stat);
1710 expect(120, height);
1711
1712 GdipDisposeImage(bitmap2);
1713 }
1714
1715 GdipDisposeImage(bitmap1);
1716
1717
1718 stat = GdipCreateBitmapFromScan0(64, 128, 0, PixelFormat32bppRGB, NULL, (GpBitmap**)&bitmap1);
1719 expect(Ok, stat);
1720
1721 stat = GdipGetImageThumbnail(bitmap1, 32, 32, &bitmap2, NULL, NULL);
1722 expect(Ok, stat);
1723
1724 if (stat == Ok)
1725 {
1726 stat = GdipGetImageWidth(bitmap2, &width);
1727 expect(Ok, stat);
1728 expect(32, width);
1729
1730 stat = GdipGetImageHeight(bitmap2, &height);
1731 expect(Ok, stat);
1732 expect(32, height);
1733
1734 GdipDisposeImage(bitmap2);
1735 }
1736
1737 stat = GdipGetImageThumbnail(bitmap1, 0, 0, &bitmap2, NULL, NULL);
1738 expect(Ok, stat);
1739
1740 if (stat == Ok)
1741 {
1742 stat = GdipGetImageWidth(bitmap2, &width);
1743 expect(Ok, stat);
1744 expect(120, width);
1745
1746 stat = GdipGetImageHeight(bitmap2, &height);
1747 expect(Ok, stat);
1748 expect(120, height);
1749
1750 GdipDisposeImage(bitmap2);
1751 }
1752
1753 GdipDisposeImage(bitmap1);
1754 }
1755
1756 static void test_getsetpixel(void)
1757 {
1758 GpStatus stat;
1759 GpBitmap *bitmap;
1760 ARGB color;
1761 BYTE bits[16] = {0x00,0x00,0x00,0x00, 0x00,0xff,0xff,0x00,
1762 0xff,0x00,0x00,0x00, 0xff,0xff,0xff,0x00};
1763
1764 stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB, bits, &bitmap);
1765 expect(Ok, stat);
1766
1767 /* null parameters */
1768 stat = GdipBitmapGetPixel(NULL, 1, 1, &color);
1769 expect(InvalidParameter, stat);
1770
1771 stat = GdipBitmapGetPixel(bitmap, 1, 1, NULL);
1772 expect(InvalidParameter, stat);
1773
1774 stat = GdipBitmapSetPixel(NULL, 1, 1, 0);
1775 expect(InvalidParameter, stat);
1776
1777 /* out of bounds */
1778 stat = GdipBitmapGetPixel(bitmap, -1, 1, &color);
1779 expect(InvalidParameter, stat);
1780
1781 stat = GdipBitmapSetPixel(bitmap, -1, 1, 0);
1782 expect(InvalidParameter, stat);
1783
1784 stat = GdipBitmapGetPixel(bitmap, 1, -1, &color);
1785 ok(stat == InvalidParameter ||
1786 broken(stat == Ok), /* Older gdiplus */
1787 "Expected InvalidParameter, got %.8x\n", stat);
1788
1789 stat = GdipBitmapSetPixel(bitmap, 1, -1, 0);
1790 ok(stat == InvalidParameter ||
1791 broken(stat == Ok), /* Older gdiplus */
1792 "Expected InvalidParameter, got %.8x\n", stat);
1793
1794 stat = GdipBitmapGetPixel(bitmap, 2, 1, &color);
1795 expect(InvalidParameter, stat);
1796
1797 stat = GdipBitmapSetPixel(bitmap, 2, 1, 0);
1798 expect(InvalidParameter, stat);
1799
1800 stat = GdipBitmapGetPixel(bitmap, 1, 2, &color);
1801 expect(InvalidParameter, stat);
1802
1803 stat = GdipBitmapSetPixel(bitmap, 1, 2, 0);
1804 expect(InvalidParameter, stat);
1805
1806 /* valid use */
1807 stat = GdipBitmapGetPixel(bitmap, 1, 1, &color);
1808 expect(Ok, stat);
1809 expect(0xffffffff, color);
1810
1811 stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
1812 expect(Ok, stat);
1813 expect(0xff0000ff, color);
1814
1815 stat = GdipBitmapSetPixel(bitmap, 1, 1, 0xff676869);
1816 expect(Ok, stat);
1817
1818 stat = GdipBitmapSetPixel(bitmap, 0, 0, 0xff474849);
1819 expect(Ok, stat);
1820
1821 stat = GdipBitmapGetPixel(bitmap, 1, 1, &color);
1822 expect(Ok, stat);
1823 expect(0xff676869, color);
1824
1825 stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1826 expect(Ok, stat);
1827 expect(0xff474849, color);
1828
1829 stat = GdipDisposeImage((GpImage*)bitmap);
1830 expect(Ok, stat);
1831 }
1832
1833 static void check_halftone_palette(ColorPalette *palette)
1834 {
1835 static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1836 UINT i;
1837
1838 for (i=0; i<palette->Count; i++)
1839 {
1840 ARGB expected=0xff000000;
1841 if (i<8)
1842 {
1843 if (i&1) expected |= 0x800000;
1844 if (i&2) expected |= 0x8000;
1845 if (i&4) expected |= 0x80;
1846 }
1847 else if (i == 8)
1848 {
1849 expected = 0xffc0c0c0;
1850 }
1851 else if (i < 16)
1852 {
1853 if (i&1) expected |= 0xff0000;
1854 if (i&2) expected |= 0xff00;
1855 if (i&4) expected |= 0xff;
1856 }
1857 else if (i < 40)
1858 {
1859 expected = 0x00000000;
1860 }
1861 else
1862 {
1863 expected |= halftone_values[(i-40)%6];
1864 expected |= halftone_values[((i-40)/6)%6] << 8;
1865 expected |= halftone_values[((i-40)/36)%6] << 16;
1866 }
1867 ok(expected == palette->Entries[i], "Expected %.8x, got %.8x, i=%u/%u\n",
1868 expected, palette->Entries[i], i, palette->Count);
1869 }
1870 }
1871
1872 static void test_palette(void)
1873 {
1874 GpStatus stat;
1875 GpBitmap *bitmap;
1876 INT size;
1877 BYTE buffer[1040];
1878 ColorPalette *palette=(ColorPalette*)buffer;
1879 ARGB *entries = palette->Entries;
1880 ARGB color=0;
1881
1882 /* test initial palette from non-indexed bitmap */
1883 stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB, NULL, &bitmap);
1884 expect(Ok, stat);
1885
1886 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1887 expect(Ok, stat);
1888 expect(sizeof(UINT)*2+sizeof(ARGB), size);
1889
1890 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1891 expect(Ok, stat);
1892 expect(0, palette->Count);
1893
1894 /* test setting palette on not-indexed bitmap */
1895 palette->Count = 3;
1896
1897 stat = GdipSetImagePalette((GpImage*)bitmap, palette);
1898 expect(Ok, stat);
1899
1900 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1901 expect(Ok, stat);
1902 expect(sizeof(UINT)*2+sizeof(ARGB)*3, size);
1903
1904 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1905 expect(Ok, stat);
1906 expect(3, palette->Count);
1907
1908 GdipDisposeImage((GpImage*)bitmap);
1909
1910 /* test initial palette on 1-bit bitmap */
1911 stat = GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat1bppIndexed, NULL, &bitmap);
1912 expect(Ok, stat);
1913
1914 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1915 expect(Ok, stat);
1916 expect(sizeof(UINT)*2+sizeof(ARGB)*2, size);
1917
1918 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1919 expect(Ok, stat);
1920 expect(PaletteFlagsGrayScale, palette->Flags);
1921 expect(2, palette->Count);
1922
1923 expect(0xff000000, entries[0]);
1924 expect(0xffffffff, entries[1]);
1925
1926 /* test getting/setting pixels */
1927 stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1928 expect(Ok, stat);
1929 expect(0xff000000, color);
1930
1931 stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffffffff);
1932 ok((stat == Ok) ||
1933 broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
1934
1935 if (stat == Ok)
1936 {
1937 stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
1938 expect(Ok, stat);
1939 expect(0xffffffff, color);
1940 }
1941
1942 GdipDisposeImage((GpImage*)bitmap);
1943
1944 /* test initial palette on 4-bit bitmap */
1945 stat = GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat4bppIndexed, NULL, &bitmap);
1946 expect(Ok, stat);
1947
1948 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1949 expect(Ok, stat);
1950 expect(sizeof(UINT)*2+sizeof(ARGB)*16, size);
1951
1952 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1953 expect(Ok, stat);
1954 expect(0, palette->Flags);
1955 expect(16, palette->Count);
1956
1957 check_halftone_palette(palette);
1958
1959 /* test getting/setting pixels */
1960 stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1961 expect(Ok, stat);
1962 expect(0xff000000, color);
1963
1964 stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffff00ff);
1965 ok((stat == Ok) ||
1966 broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
1967
1968 if (stat == Ok)
1969 {
1970 stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
1971 expect(Ok, stat);
1972 expect(0xffff00ff, color);
1973 }
1974
1975 GdipDisposeImage((GpImage*)bitmap);
1976
1977 /* test initial palette on 8-bit bitmap */
1978 stat = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat8bppIndexed, NULL, &bitmap);
1979 expect(Ok, stat);
1980
1981 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
1982 expect(Ok, stat);
1983 expect(sizeof(UINT)*2+sizeof(ARGB)*256, size);
1984
1985 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
1986 expect(Ok, stat);
1987 expect(PaletteFlagsHalftone, palette->Flags);
1988 expect(256, palette->Count);
1989
1990 check_halftone_palette(palette);
1991
1992 /* test getting/setting pixels */
1993 stat = GdipBitmapGetPixel(bitmap, 0, 0, &color);
1994 expect(Ok, stat);
1995 expect(0xff000000, color);
1996
1997 stat = GdipBitmapSetPixel(bitmap, 0, 1, 0xffcccccc);
1998 ok((stat == Ok) ||
1999 broken(stat == InvalidParameter) /* pre-win7 */, "stat=%.8x\n", stat);
2000
2001 if (stat == Ok)
2002 {
2003 stat = GdipBitmapGetPixel(bitmap, 0, 1, &color);
2004 expect(Ok, stat);
2005 expect(0xffcccccc, color);
2006 }
2007
2008 /* test setting/getting a different palette */
2009 entries[1] = 0xffcccccc;
2010
2011 stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2012 expect(Ok, stat);
2013
2014 entries[1] = 0;
2015
2016 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2017 expect(Ok, stat);
2018 expect(sizeof(UINT)*2+sizeof(ARGB)*256, size);
2019
2020 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2021 expect(Ok, stat);
2022 expect(PaletteFlagsHalftone, palette->Flags);
2023 expect(256, palette->Count);
2024 expect(0xffcccccc, entries[1]);
2025
2026 /* test count < 256 */
2027 palette->Flags = 12345;
2028 palette->Count = 3;
2029
2030 stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2031 expect(Ok, stat);
2032
2033 entries[1] = 0;
2034 entries[3] = 0xdeadbeef;
2035
2036 stat = GdipGetImagePaletteSize((GpImage*)bitmap, &size);
2037 expect(Ok, stat);
2038 expect(sizeof(UINT)*2+sizeof(ARGB)*3, size);
2039
2040 stat = GdipGetImagePalette((GpImage*)bitmap, palette, size);
2041 expect(Ok, stat);
2042 expect(12345, palette->Flags);
2043 expect(3, palette->Count);
2044 expect(0xffcccccc, entries[1]);
2045 expect(0xdeadbeef, entries[3]);
2046
2047 /* test count > 256 */
2048 palette->Count = 257;
2049
2050 stat = GdipSetImagePalette((GpImage*)bitmap, palette);
2051 ok(stat == InvalidParameter ||
2052 broken(stat == Ok), /* Old gdiplus behavior */
2053 "Expected %.8x, got %.8x\n", InvalidParameter, stat);
2054
2055 GdipDisposeImage((GpImage*)bitmap);
2056 }
2057
2058 static void test_colormatrix(void)
2059 {
2060 GpStatus stat;
2061 ColorMatrix colormatrix, graymatrix;
2062 GpImageAttributes *imageattr;
2063 const ColorMatrix identity = {{
2064 {1.0,0.0,0.0,0.0,0.0},
2065 {0.0,1.0,0.0,0.0,0.0},
2066 {0.0,0.0,1.0,0.0,0.0},
2067 {0.0,0.0,0.0,1.0,0.0},
2068 {0.0,0.0,0.0,0.0,1.0}}};
2069 const ColorMatrix double_red = {{
2070 {2.0,0.0,0.0,0.0,0.0},
2071 {0.0,1.0,0.0,0.0,0.0},
2072 {0.0,0.0,1.0,0.0,0.0},
2073 {0.0,0.0,0.0,1.0,0.0},
2074 {0.0,0.0,0.0,0.0,1.0}}};
2075 const ColorMatrix asymmetric = {{
2076 {0.0,1.0,0.0,0.0,0.0},
2077 {0.0,0.0,1.0,0.0,0.0},
2078 {0.0,0.0,0.0,1.0,0.0},
2079 {1.0,0.0,0.0,0.0,0.0},
2080 {0.0,0.0,0.0,0.0,1.0}}};
2081 GpBitmap *bitmap1, *bitmap2;
2082 GpGraphics *graphics;
2083 ARGB color;
2084
2085 colormatrix = identity;
2086 graymatrix = identity;
2087
2088 stat = GdipSetImageAttributesColorMatrix(NULL, ColorAdjustTypeDefault,
2089 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2090 expect(InvalidParameter, stat);
2091
2092 stat = GdipCreateImageAttributes(&imageattr);
2093 expect(Ok, stat);
2094
2095 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2096 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2097 expect(Ok, stat);
2098
2099 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2100 TRUE, NULL, NULL, ColorMatrixFlagsDefault);
2101 expect(InvalidParameter, stat);
2102
2103 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2104 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2105 expect(Ok, stat);
2106
2107 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2108 TRUE, &colormatrix, NULL, ColorMatrixFlagsSkipGrays);
2109 expect(Ok, stat);
2110
2111 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2112 TRUE, &colormatrix, NULL, ColorMatrixFlagsAltGray);
2113 expect(InvalidParameter, stat);
2114
2115 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2116 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsAltGray);
2117 expect(Ok, stat);
2118
2119 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2120 TRUE, &colormatrix, &graymatrix, 3);
2121 expect(InvalidParameter, stat);
2122
2123 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeCount,
2124 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2125 expect(InvalidParameter, stat);
2126
2127 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeAny,
2128 TRUE, &colormatrix, &graymatrix, ColorMatrixFlagsDefault);
2129 expect(InvalidParameter, stat);
2130
2131 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2132 FALSE, NULL, NULL, ColorMatrixFlagsDefault);
2133 expect(Ok, stat);
2134
2135 /* Drawing a bitmap transforms the colors */
2136 colormatrix = double_red;
2137 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2138 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2139 expect(Ok, stat);
2140
2141 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap1);
2142 expect(Ok, stat);
2143
2144 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB, NULL, &bitmap2);
2145 expect(Ok, stat);
2146
2147 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff40ccee);
2148 expect(Ok, stat);
2149
2150 stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2151 expect(Ok, stat);
2152
2153 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2154 UnitPixel, imageattr, NULL, NULL);
2155 expect(Ok, stat);
2156
2157 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2158 expect(Ok, stat);
2159 expect(0xff80ccee, color);
2160
2161 colormatrix = asymmetric;
2162 stat = GdipSetImageAttributesColorMatrix(imageattr, ColorAdjustTypeDefault,
2163 TRUE, &colormatrix, NULL, ColorMatrixFlagsDefault);
2164 expect(Ok, stat);
2165
2166 stat = GdipBitmapSetPixel(bitmap2, 0, 0, 0);
2167 expect(Ok, stat);
2168
2169 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2170 UnitPixel, imageattr, NULL, NULL);
2171 expect(Ok, stat);
2172
2173 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2174 expect(Ok, stat);
2175 ok(color_match(0xeeff40cc, color, 3), "expected 0xeeff40cc, got 0x%08x\n", color);
2176
2177 GdipDeleteGraphics(graphics);
2178 GdipDisposeImage((GpImage*)bitmap1);
2179 GdipDisposeImage((GpImage*)bitmap2);
2180 GdipDisposeImageAttributes(imageattr);
2181 }
2182
2183 static void test_gamma(void)
2184 {
2185 GpStatus stat;
2186 GpImageAttributes *imageattr;
2187 GpBitmap *bitmap1, *bitmap2;
2188 GpGraphics *graphics;
2189 ARGB color;
2190
2191 stat = GdipSetImageAttributesGamma(NULL, ColorAdjustTypeDefault, TRUE, 1.0);
2192 expect(InvalidParameter, stat);
2193
2194 stat = GdipCreateImageAttributes(&imageattr);
2195 expect(Ok, stat);
2196
2197 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 1.0);
2198 expect(Ok, stat);
2199
2200 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeAny, TRUE, 1.0);
2201 expect(InvalidParameter, stat);
2202
2203 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, -1.0);
2204 expect(InvalidParameter, stat);
2205
2206 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.0);
2207 expect(InvalidParameter, stat);
2208
2209 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 0.5);
2210 expect(Ok, stat);
2211
2212 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, FALSE, 0.0);
2213 expect(Ok, stat);
2214
2215 /* Drawing a bitmap transforms the colors */
2216 stat = GdipSetImageAttributesGamma(imageattr, ColorAdjustTypeDefault, TRUE, 3.0);
2217 expect(Ok, stat);
2218
2219 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap1);
2220 expect(Ok, stat);
2221
2222 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap2);
2223 expect(Ok, stat);
2224
2225 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff80ffff);
2226 expect(Ok, stat);
2227
2228 stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2229 expect(Ok, stat);
2230
2231 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2232 UnitPixel, imageattr, NULL, NULL);
2233 expect(Ok, stat);
2234
2235 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2236 expect(Ok, stat);
2237 ok(color_match(0xff20ffff, color, 1), "Expected ff20ffff, got %.8x\n", color);
2238
2239 GdipDeleteGraphics(graphics);
2240 GdipDisposeImage((GpImage*)bitmap1);
2241 GdipDisposeImage((GpImage*)bitmap2);
2242 GdipDisposeImageAttributes(imageattr);
2243 }
2244
2245 /* 1x1 pixel gif, 2 frames; first frame is white, second is black */
2246 static const unsigned char gifanimation[72] = {
2247 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
2248 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x21,0xf9,0x04,0x00,0x0a,0x00,0xff,
2249 0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x4c,0x01,0x00,
2250 0x21,0xf9,0x04,0x01,0x0a,0x00,0x01,0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
2251 0x00,0x00,0x02,0x02,0x44,0x01,0x00,0x3b
2252 };
2253
2254 static void test_multiframegif(void)
2255 {
2256 LPSTREAM stream;
2257 HGLOBAL hglob;
2258 LPBYTE data;
2259 HRESULT hres;
2260 GpStatus stat;
2261 GpBitmap *bmp;
2262 ARGB color;
2263 UINT count;
2264 GUID dimension;
2265
2266 /* Test frame functions with an animated GIF */
2267 hglob = GlobalAlloc (0, sizeof(gifanimation));
2268 data = GlobalLock (hglob);
2269 memcpy(data, gifanimation, sizeof(gifanimation));
2270 GlobalUnlock(hglob);
2271
2272 hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
2273 ok(hres == S_OK, "Failed to create a stream\n");
2274 if(hres != S_OK) return;
2275
2276 stat = GdipCreateBitmapFromStream(stream, &bmp);
2277 ok(stat == Ok, "Failed to create a Bitmap\n");
2278 if(stat != Ok){
2279 IStream_Release(stream);
2280 return;
2281 }
2282
2283 /* Bitmap starts at frame 0 */
2284 color = 0xdeadbeef;
2285 stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2286 expect(Ok, stat);
2287 expect(0xffffffff, color);
2288
2289 /* Check that we get correct metadata */
2290 stat = GdipImageGetFrameDimensionsCount((GpImage*)bmp,&count);
2291 expect(Ok, stat);
2292 expect(1, count);
2293
2294 stat = GdipImageGetFrameDimensionsList((GpImage*)bmp, &dimension, 1);
2295 expect(Ok, stat);
2296 expect_guid(&FrameDimensionTime, &dimension, __LINE__, FALSE);
2297
2298 count = 12345;
2299 stat = GdipImageGetFrameCount((GpImage*)bmp, &dimension, &count);
2300 expect(Ok, stat);
2301 expect(2, count);
2302
2303 /* SelectActiveFrame overwrites our current data */
2304 stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 1);
2305 expect(Ok, stat);
2306
2307 color = 0xdeadbeef;
2308 GdipBitmapGetPixel(bmp, 0, 0, &color);
2309 expect(Ok, stat);
2310 expect(0xff000000, color);
2311
2312 stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2313 expect(Ok, stat);
2314
2315 color = 0xdeadbeef;
2316 GdipBitmapGetPixel(bmp, 0, 0, &color);
2317 expect(Ok, stat);
2318 expect(0xffffffff, color);
2319
2320 /* Write over the image data */
2321 stat = GdipBitmapSetPixel(bmp, 0, 0, 0xff000000);
2322 expect(Ok, stat);
2323
2324 /* Switching to the same frame does not overwrite our changes */
2325 stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2326 expect(Ok, stat);
2327
2328 stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2329 expect(Ok, stat);
2330 expect(0xff000000, color);
2331
2332 /* But switching to another frame and back does */
2333 stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 1);
2334 expect(Ok, stat);
2335
2336 stat = GdipImageSelectActiveFrame((GpImage*)bmp, &dimension, 0);
2337 expect(Ok, stat);
2338
2339 stat = GdipBitmapGetPixel(bmp, 0, 0, &color);
2340 expect(Ok, stat);
2341 expect(0xffffffff, color);
2342
2343 GdipDisposeImage((GpImage*)bmp);
2344 IStream_Release(stream);
2345
2346 /* Test with a non-animated gif */
2347 hglob = GlobalAlloc (0, sizeof(gifimage));
2348 data = GlobalLock (hglob);
2349 memcpy(data, gifimage, sizeof(gifimage));
2350 GlobalUnlock(hglob);
2351
2352 hres = CreateStreamOnHGlobal(hglob, TRUE, &stream);
2353 ok(hres == S_OK, "Failed to create a stream\n");
2354 if(hres != S_OK) return;
2355
2356 stat = GdipCreateBitmapFromStream(stream, &bmp);
2357 ok(stat == Ok, "Failed to create a Bitmap\n");
2358 if(stat != Ok){
2359 IStream_Release(stream);
2360 return;
2361 }
2362
2363 /* Check metadata */
2364 stat = GdipImageGetFrameDimensionsCount((GpImage*)bmp,&count);
2365 expect(Ok, stat);
2366 expect(1, count);
2367
2368 stat = GdipImageGetFrameDimensionsList((GpImage*)bmp, &dimension, 1);
2369 expect(Ok, stat);
2370 expect_guid(&FrameDimensionTime, &dimension, __LINE__, FALSE);
2371
2372 count = 12345;
2373 stat = GdipImageGetFrameCount((GpImage*)bmp, &dimension, &count);
2374 expect(Ok, stat);
2375 expect(1, count);
2376
2377 GdipDisposeImage((GpImage*)bmp);
2378 IStream_Release(stream);
2379 }
2380
2381 static void test_rotateflip(void)
2382 {
2383 GpImage *bitmap;
2384 GpStatus stat;
2385 BYTE bits[24];
2386 static const BYTE orig_bits[24] = {
2387 0,0,0xff, 0,0xff,0, 0xff,0,0, 23,23,23,
2388 0xff,0xff,0, 0xff,0,0xff, 0,0xff,0xff, 23,23,23};
2389 UINT width, height;
2390 ARGB color;
2391
2392 memcpy(bits, orig_bits, sizeof(bits));
2393 stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2394 expect(Ok, stat);
2395
2396 stat = GdipImageRotateFlip(bitmap, Rotate90FlipNone);
2397 expect(Ok, stat);
2398
2399 stat = GdipGetImageWidth(bitmap, &width);
2400 expect(Ok, stat);
2401 stat = GdipGetImageHeight(bitmap, &height);
2402 expect(Ok, stat);
2403 expect(2, width);
2404 expect(3, height);
2405
2406 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2407 expect(Ok, stat);
2408 expect(0xff00ffff, color);
2409
2410 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 1, 0, &color);
2411 expect(Ok, stat);
2412 expect(0xffff0000, color);
2413
2414 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 2, &color);
2415 expect(Ok, stat);
2416 expect(0xffffff00, color);
2417
2418 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 1, 2, &color);
2419 expect(Ok, stat);
2420 expect(0xff0000ff, color);
2421
2422 expect(0, bits[0]);
2423 expect(0, bits[1]);
2424 expect(0xff, bits[2]);
2425
2426 GdipDisposeImage(bitmap);
2427
2428 memcpy(bits, orig_bits, sizeof(bits));
2429 stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2430 expect(Ok, stat);
2431
2432 stat = GdipImageRotateFlip(bitmap, RotateNoneFlipX);
2433 expect(Ok, stat);
2434
2435 stat = GdipGetImageWidth(bitmap, &width);
2436 expect(Ok, stat);
2437 stat = GdipGetImageHeight(bitmap, &height);
2438 expect(Ok, stat);
2439 expect(3, width);
2440 expect(2, height);
2441
2442 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2443 expect(Ok, stat);
2444 expect(0xff0000ff, color);
2445
2446 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 0, &color);
2447 expect(Ok, stat);
2448 expect(0xffff0000, color);
2449
2450 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 1, &color);
2451 expect(Ok, stat);
2452 expect(0xffffff00, color);
2453
2454 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 1, &color);
2455 expect(Ok, stat);
2456 expect(0xff00ffff, color);
2457
2458 expect(0, bits[0]);
2459 expect(0, bits[1]);
2460 expect(0xff, bits[2]);
2461
2462 GdipDisposeImage(bitmap);
2463
2464 memcpy(bits, orig_bits, sizeof(bits));
2465 stat = GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB, bits, (GpBitmap**)&bitmap);
2466 expect(Ok, stat);
2467
2468 stat = GdipImageRotateFlip(bitmap, RotateNoneFlipY);
2469 expect(Ok, stat);
2470
2471 stat = GdipGetImageWidth(bitmap, &width);
2472 expect(Ok, stat);
2473 stat = GdipGetImageHeight(bitmap, &height);
2474 expect(Ok, stat);
2475 expect(3, width);
2476 expect(2, height);
2477
2478 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 0, &color);
2479 expect(Ok, stat);
2480 expect(0xff00ffff, color);
2481
2482 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 0, &color);
2483 expect(Ok, stat);
2484 expect(0xffffff00, color);
2485
2486 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 0, 1, &color);
2487 expect(Ok, stat);
2488 expect(0xffff0000, color);
2489
2490 stat = GdipBitmapGetPixel((GpBitmap*)bitmap, 2, 1, &color);
2491 expect(Ok, stat);
2492 expect(0xff0000ff, color);
2493
2494 expect(0, bits[0]);
2495 expect(0, bits[1]);
2496 expect(0xff, bits[2]);
2497
2498 GdipDisposeImage(bitmap);
2499 }
2500
2501 static void test_remaptable(void)
2502 {
2503 GpStatus stat;
2504 GpImageAttributes *imageattr;
2505 GpBitmap *bitmap1, *bitmap2;
2506 GpGraphics *graphics;
2507 ARGB color;
2508 ColorMap *map;
2509
2510 map = GdipAlloc(sizeof(ColorMap));
2511
2512 map->oldColor.Argb = 0xff00ff00;
2513 map->newColor.Argb = 0xffff00ff;
2514
2515 stat = GdipSetImageAttributesRemapTable(NULL, ColorAdjustTypeDefault, TRUE, 1, map);
2516 expect(InvalidParameter, stat);
2517
2518 stat = GdipCreateImageAttributes(&imageattr);
2519 expect(Ok, stat);
2520
2521 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 1, NULL);
2522 expect(InvalidParameter, stat);
2523
2524 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeCount, TRUE, 1, map);
2525 expect(InvalidParameter, stat);
2526
2527 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeAny, TRUE, 1, map);
2528 expect(InvalidParameter, stat);
2529
2530 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 0, map);
2531 expect(InvalidParameter, stat);
2532
2533 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, FALSE, 0, NULL);
2534 expect(Ok, stat);
2535
2536 stat = GdipSetImageAttributesRemapTable(imageattr, ColorAdjustTypeDefault, TRUE, 1, map);
2537 expect(Ok, stat);
2538
2539 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap1);
2540 expect(Ok, stat);
2541
2542 stat = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB, NULL, &bitmap2);
2543 expect(Ok, stat);
2544
2545 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0xff00ff00);
2546 expect(Ok, stat);
2547
2548 stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2549 expect(Ok, stat);
2550
2551 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,1,1, 0,0,1,1,
2552 UnitPixel, imageattr, NULL, NULL);
2553 expect(Ok, stat);
2554
2555 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2556 expect(Ok, stat);
2557 ok(color_match(0xffff00ff, color, 1), "Expected ffff00ff, got %.8x\n", color);
2558
2559 GdipDeleteGraphics(graphics);
2560 GdipDisposeImage((GpImage*)bitmap1);
2561 GdipDisposeImage((GpImage*)bitmap2);
2562 GdipDisposeImageAttributes(imageattr);
2563 GdipFree(map);
2564 }
2565
2566 static void test_colorkey(void)
2567 {
2568 GpStatus stat;
2569 GpImageAttributes *imageattr;
2570 GpBitmap *bitmap1, *bitmap2;
2571 GpGraphics *graphics;
2572 ARGB color;
2573
2574 stat = GdipSetImageAttributesColorKeys(NULL, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
2575 expect(InvalidParameter, stat);
2576
2577 stat = GdipCreateImageAttributes(&imageattr);
2578 expect(Ok, stat);
2579
2580 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeCount, TRUE, 0xff405060, 0xff708090);
2581 expect(InvalidParameter, stat);
2582
2583 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeAny, TRUE, 0xff405060, 0xff708090);
2584 expect(InvalidParameter, stat);
2585
2586 stat = GdipSetImageAttributesColorKeys(imageattr, ColorAdjustTypeDefault, TRUE, 0xff405060, 0xff708090);
2587 expect(Ok, stat);
2588
2589 stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap1);
2590 expect(Ok, stat);
2591
2592 stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, &bitmap2);
2593 expect(Ok, stat);
2594
2595 stat = GdipBitmapSetPixel(bitmap1, 0, 0, 0x20405060);
2596 expect(Ok, stat);
2597
2598 stat = GdipBitmapSetPixel(bitmap1, 0, 1, 0x40506070);
2599 expect(Ok, stat);
2600
2601 stat = GdipBitmapSetPixel(bitmap1, 1, 0, 0x60708090);
2602 expect(Ok, stat);
2603
2604 stat = GdipBitmapSetPixel(bitmap1, 1, 1, 0xffffffff);
2605 expect(Ok, stat);
2606
2607 stat = GdipGetImageGraphicsContext((GpImage*)bitmap2, &graphics);
2608 expect(Ok, stat);
2609
2610 stat = GdipDrawImageRectRectI(graphics, (GpImage*)bitmap1, 0,0,2,2, 0,0,2,2,
2611 UnitPixel, imageattr, NULL, NULL);
2612 expect(Ok, stat);
2613
2614 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
2615 expect(Ok, stat);
2616 ok(color_match(0x00000000, color, 1), "Expected ffff00ff, got %.8x\n", color);
2617
2618 stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
2619 expect(Ok, stat);
2620 ok(color_match(0x00000000, color, 1), "Expected ffff00ff, got %.8x\n", color);
2621
2622 stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
2623 expect(Ok, stat);
2624 ok(color_match(0x00000000, color, 1), "Expected ffff00ff, got %.8x\n", color);
2625
2626 stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
2627 expect(Ok, stat);
2628 ok(color_match(0xffffffff, color, 1), "Expected ffff00ff, got %.8x\n", color);
2629
2630 GdipDeleteGraphics(graphics);
2631 GdipDisposeImage((GpImage*)bitmap1);
2632 GdipDisposeImage((GpImage*)bitmap2);
2633 GdipDisposeImageAttributes(imageattr);
2634 }
2635
2636 static void test_dispose(void)
2637 {
2638 GpStatus stat;
2639 GpImage *image;
2640 char invalid_image[256];
2641
2642 stat = GdipDisposeImage(NULL);
2643 expect(InvalidParameter, stat);
2644
2645 stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, (GpBitmap**)&image);
2646 expect(Ok, stat);
2647
2648 stat = GdipDisposeImage(image);
2649 expect(Ok, stat);
2650
2651 stat = GdipDisposeImage(image);
2652 expect(ObjectBusy, stat);
2653
2654 memset(invalid_image, 0, 256);
2655 stat = GdipDisposeImage((GpImage*)invalid_image);
2656 expect(ObjectBusy, stat);
2657 }
2658
2659 static LONG obj_refcount(void *obj)
2660 {
2661 IUnknown_AddRef((IUnknown *)obj);
2662 return IUnknown_Release((IUnknown *)obj);
2663 }
2664
2665 static GpImage *load_image(const BYTE *image_data, UINT image_size)
2666 {
2667 IStream *stream;
2668 HGLOBAL hmem;
2669 BYTE *data;
2670 HRESULT hr;
2671 GpStatus status;
2672 GpImage *image = NULL;
2673 ImageType image_type;
2674 LONG refcount;
2675
2676 hmem = GlobalAlloc(0, image_size);
2677 data = GlobalLock(hmem);
2678 memcpy(data, image_data, image_size);
2679 GlobalUnlock(hmem);
2680
2681 hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
2682 ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
2683 if (hr != S_OK) return NULL;
2684
2685 refcount = obj_refcount(stream);
2686 ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
2687
2688 status = GdipLoadImageFromStream(stream, &image);
2689 ok(status == Ok, "GdipLoadImageFromStream error %d\n", status);
2690
2691 status = GdipGetImageType(image, &image_type);
2692 ok(status == Ok, "GdipGetImageType error %d\n", status);
2693
2694 refcount = IStream_Release(stream);
2695 if (image_type == ImageTypeBitmap)
2696 ok(refcount >= 1, "expected stream refcount != 0\n");
2697 else
2698 ok(refcount == 0, "expected stream refcount 0, got %d\n", refcount);
2699
2700 return image;
2701 }
2702
2703 static void test_image_properties(void)
2704 {
2705 static const struct test_data
2706 {
2707 const BYTE *image_data;
2708 UINT image_size;
2709 ImageType image_type;
2710 UINT prop_count;
2711 }
2712 td[] =
2713 {
2714 { pngimage, sizeof(pngimage), ImageTypeBitmap, 4 },
2715 /* Win7 reports 4 properties, while everybody else just 1
2716 { gifimage, sizeof(gifimage), ImageTypeBitmap, 1 }, */
2717 { jpgimage, sizeof(jpgimage), ImageTypeBitmap, 2 },
2718 { tiffimage, sizeof(tiffimage), ImageTypeBitmap, 16 },
2719 { bmpimage, sizeof(bmpimage), ImageTypeBitmap, 0 },
2720 { wmfimage, sizeof(wmfimage), ImageTypeMetafile, 0 }
2721 };
2722 GpStatus status;
2723 GpImage *image;
2724 UINT prop_count, i;
2725 PROPID prop_id[16];
2726 ImageType image_type;
2727
2728 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
2729 {
2730 image = load_image(td[i].image_data, td[i].image_size);
2731 ok(image != 0, "%u: failed to load image data\n", i);
2732 if (!image) continue;
2733
2734 status = GdipGetImageType(image, &image_type);
2735 ok(status == Ok, "%u: GdipGetImageType error %d\n", i, status);
2736 ok(td[i].image_type == image_type, "%u: expected image_type %d, got %d\n",
2737 i, td[i].image_type, image_type);
2738
2739 status = GdipGetPropertyCount(image, &prop_count);
2740 ok(status == Ok, "%u: GdipGetPropertyCount error %d\n", i, status);
2741 if (td[i].image_data == pngimage || td[i].image_data == gifimage ||
2742 td[i].image_data == jpgimage)
2743 todo_wine
2744 ok(td[i].prop_count == prop_count, " %u: expected property count %u, got %u\n",
2745 i, td[i].prop_count, prop_count);
2746 else
2747 ok(td[i].prop_count == prop_count, " %u: expected property count %u, got %u\n",
2748 i, td[i].prop_count, prop_count);
2749
2750 if (td[i].prop_count != prop_count)
2751 {
2752 GdipDisposeImage(image);
2753 continue;
2754 }
2755
2756 status = GdipGetPropertyIdList(NULL, prop_count, prop_id);
2757 expect(InvalidParameter, status);
2758 status = GdipGetPropertyIdList(image, prop_count, NULL);
2759 expect(InvalidParameter, status);
2760 status = GdipGetPropertyIdList(image, 0, prop_id);
2761 if (image_type == ImageTypeMetafile)
2762 expect(NotImplemented, status);
2763 else if (prop_count == 0)
2764 expect(Ok, status);
2765 else
2766 expect(InvalidParameter, status);
2767 status = GdipGetPropertyIdList(image, prop_count - 1, prop_id);
2768 if (image_type == ImageTypeMetafile)
2769 expect(NotImplemented, status);
2770 else
2771 expect(InvalidParameter, status);
2772 status = GdipGetPropertyIdList(image, prop_count + 1, prop_id);
2773 if (image_type == ImageTypeMetafile)
2774 expect(NotImplemented, status);
2775 else
2776 expect(InvalidParameter, status);
2777 status = GdipGetPropertyIdList(image, prop_count, prop_id);
2778 if (image_type == ImageTypeMetafile)
2779 expect(NotImplemented, status);
2780 else
2781 expect(Ok, status);
2782
2783 GdipDisposeImage(image);
2784 }
2785 }
2786
2787 START_TEST(image)
2788 {
2789 struct GdiplusStartupInput gdiplusStartupInput;
2790 ULONG_PTR gdiplusToken;
2791
2792 gdiplusStartupInput.GdiplusVersion = 1;
2793 gdiplusStartupInput.DebugEventCallback = NULL;
2794 gdiplusStartupInput.SuppressBackgroundThread = 0;
2795 gdiplusStartupInput.SuppressExternalCodecs = 0;
2796
2797 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
2798
2799 test_image_properties();
2800 test_Scan0();
2801 test_FromGdiDib();
2802 test_GetImageDimension();
2803 test_GdipImageGetFrameDimensionsCount();
2804 test_LoadingImages();
2805 test_SavingImages();
2806 test_encoders();
2807 test_LockBits();
2808 test_LockBits_UserBuf();
2809 test_GdipCreateBitmapFromHBITMAP();
2810 test_GdipGetImageFlags();
2811 test_GdipCloneImage();
2812 test_testcontrol();
2813 test_fromhicon();
2814 test_getrawformat();
2815 test_loadwmf();
2816 test_createfromwmf();
2817 test_resolution();
2818 test_createhbitmap();
2819 test_getthumbnail();
2820 test_getsetpixel();
2821 test_palette();
2822 test_colormatrix();
2823 test_gamma();
2824 test_multiframegif();
2825 test_rotateflip();
2826 test_remaptable();
2827 test_colorkey();
2828 test_dispose();
2829
2830 GdiplusShutdown(gdiplusToken);
2831 }
Maarten's multimedia branch