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