[GDIPLUS_WINETEST]
[reactos.git] / 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(<