projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[SHELL32] Remove 2 redundant initializations
[reactos.git] / modules / rostests / winetests / gdiplus / image.c
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 */
38 DEFINE_GUID(BlurEffectGuid, 0x633c80a4, 0x1843, 0x482b, 0x9e, 0xf2, 0xbe, 0x28, 0x34, 0xc5, 0xfd, 0xd4);
39 DEFINE_GUID(SharpenEffectGuid, 0x63cbf3ee, 0xc526, 0x402c, 0x8f, 0x71, 0x62, 0xc5, 0x40, 0xbf, 0x51, 0x42);
40 DEFINE_GUID(ColorMatrixEffectGuid, 0x718f2615, 0x7933, 0x40e3, 0xa5, 0x11, 0x5f, 0x68, 0xfe, 0x14, 0xdd, 0x74);
41 DEFINE_GUID(ColorLUTEffectGuid, 0xa7ce72a9, 0x0f7f, 0x40d7, 0xb3, 0xcc, 0xd0, 0xc0, 0x2d, 0x5c, 0x32, 0x12);
42 DEFINE_GUID(BrightnessContrastEffectGuid, 0xd3a1dbe1, 0x8ec4, 0x4c17, 0x9f, 0x4c, 0xea, 0x97, 0xad, 0x1c, 0x34, 0x3d);
43 DEFINE_GUID(HueSaturationLightnessEffectGuid, 0x8b2dd6c3, 0xeb07, 0x4d87, 0xa5, 0xf0, 0x71, 0x08, 0xe2, 0x6a, 0x9c, 0x5f);
44 DEFINE_GUID(LevelsEffectGuid, 0x99c354ec, 0x2a31, 0x4f3a, 0x8c, 0x34, 0x17, 0xa8, 0x03, 0xb3, 0x3a, 0x25);
45 DEFINE_GUID(TintEffectGuid, 0x1077af00, 0x2848, 0x4441, 0x94, 0x89, 0x44, 0xad, 0x4c, 0x2d, 0x7a, 0x2c);
46 DEFINE_GUID(ColorBalanceEffectGuid, 0x537e597d, 0x251e, 0x48da, 0x96, 0x64, 0x29, 0xca, 0x49, 0x6b, 0x70, 0xf8);
47 DEFINE_GUID(RedEyeCorrectionEffectGuid, 0x74d29d05, 0x69a4, 0x4266, 0x95, 0x49, 0x3c, 0xc5, 0x28, 0x36, 0xb6, 0x32);
48 DEFINE_GUID(ColorCurveEffectGuid, 0xdd6a0022, 0x58e4, 0x4a67, 0x9d, 0x9b, 0xd4, 0x8e, 0xb8, 0x81, 0xa5, 0x3d);
49
50 static GpStatus (WINAPI *pGdipBitmapGetHistogramSize)(HistogramFormat,UINT*);
51 static GpStatus (WINAPI *pGdipBitmapGetHistogram)(GpBitmap*,HistogramFormat,UINT,UINT*,UINT*,UINT*,UINT*);
52 static GpStatus (WINAPI *pGdipImageSetAbort)(GpImage*,GdiplusAbort*);
53
54 static 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
59 static 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
71 static 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
85 static 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
96 static 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
127 static 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
185 static 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
296 static 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
327 static 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
396 static 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
443 static 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
507 static 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
561 static 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
799 static 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
883 struct BITMAPINFOWITHBITFIELDS
884 {
885 BITMAPINFOHEADER bmiHeader;
886 DWORD masks[3];
887 };
888
889 union BITMAPINFOUNION
890 {
891 BITMAPINFO bi;
892 struct BITMAPINFOWITHBITFIELDS bf;
893 };
894
895 static 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
1079 static 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
1206 static 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
1238 static 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
1249 static 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 */
1345 static const unsigned char pngimage[285] = {
1346 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
1347 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
1348 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
1349 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
1350 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
1351 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
1352 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
1353 };
1354 /* 1x1 pixel gif */
1355 static const unsigned char gifimage[35] = {
1356 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
1357 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
1358 0x01,0x00,0x3b
1359 };
1360 /* 1x1 pixel transparent gif */
1361 static const unsigned char transparentgif[] = {
1362 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xf0,0x00,0x00,0x00,0x00,0x00,
1363 0x00,0x00,0x00,0x21,0xf9,0x04,0x01,0x00,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,0x00,
1364 0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,0x01,0x00,0x3b
1365 };
1366 /* 1x1 pixel bmp */
1367 static const unsigned char bmpimage[66] = {
1368 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
1369 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
1370 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
1371 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
1372 0x00,0x00
1373 };
1374 /* 1x1 pixel jpg */
1375 static const unsigned char jpgimage[285] = {
1376 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
1377 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
1378 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
1379 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
1380 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
1381 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
1382 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
1383 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1384 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1385 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
1386 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
1387 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1388 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
1389 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
1390 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1391 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
1392 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
1393 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
1394 };
1395 /* 1x1 pixel tiff */
1396 static const unsigned char tiffimage[] = {
1397 0x49,0x49,0x2a,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0xfe,0x00,
1398 0x04,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x00,0x01,0x00,
1399 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1400 0x00,0x00,0x02,0x01,0x03,0x00,0x03,0x00,0x00,0x00,0xd2,0x00,0x00,0x00,0x03,0x01,
1401 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x01,0x03,0x00,0x01,0x00,
1402 0x00,0x00,0x02,0x00,0x00,0x00,0x0d,0x01,0x02,0x00,0x1b,0x00,0x00,0x00,0xd8,0x00,
1403 0x00,0x00,0x11,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x12,0x01,
1404 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x01,0x03,0x00,0x01,0x00,
1405 0x00,0x00,0x03,0x00,0x00,0x00,0x16,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x40,0x00,
1406 0x00,0x00,0x17,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x1a,0x01,
1407 0x05,0x00,0x01,0x00,0x00,0x00,0xf4,0x00,0x00,0x00,0x1b,0x01,0x05,0x00,0x01,0x00,
1408 0x00,0x00,0xfc,0x00,0x00,0x00,0x1c,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1409 0x00,0x00,0x28,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
1410 0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x2f,0x68,0x6f,0x6d,0x65,0x2f,0x6d,0x65,
1411 0x68,0x2f,0x44,0x65,0x73,0x6b,0x74,0x6f,0x70,0x2f,0x74,0x65,0x73,0x74,0x2e,0x74,
1412 0x69,0x66,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x48,
1413 0x00,0x00,0x00,0x01
1414 };
1415 /* 320x320 twip wmf */
1416 static const unsigned char wmfimage[180] = {
1417 0xd7,0xcd,0xc6,0x9a,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0x40,0x01,0xa0,0x05,
1418 0x00,0x00,0x00,0x00,0xb1,0x52,0x01,0x00,0x09,0x00,0x00,0x03,0x4f,0x00,0x00,0x00,
1419 0x0f,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0b,0x02,0x00,0x00,
1420 0x00,0x00,0x05,0x00,0x00,0x00,0x0c,0x02,0x40,0x01,0x40,0x01,0x04,0x00,0x00,0x00,
1421 0x02,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x04,0x01,0x0d,0x00,0x08,0x00,0x00,0x00,
1422 0xfa,0x02,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
1423 0x2d,0x01,0x00,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,0x01,0x00,0x00,0x00,0x00,0x00,
1424 0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x01,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,
1425 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x02,0x00,
1426 0x07,0x00,0x00,0x00,0x1b,0x04,0x40,0x01,0x40,0x01,0x00,0x00,0x00,0x00,0x04,0x00,
1427 0x00,0x00,0xf0,0x01,0x00,0x00,0x04,0x00,0x00,0x00,0xf0,0x01,0x01,0x00,0x03,0x00,
1428 0x00,0x00,0x00,0x00
1429 };
1430 static 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
1440 static 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
1511 static 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
1569 static 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
1585 static 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
1679 static 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
1901 static 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
1973 static 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
2006 if (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
2053 static 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
2092 static 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
2278 static 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
2543 static 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 */
2617 static const unsigned char gifanimation[72] = {
2618 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
2619 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x21,0xf9,0x04,0x00,0x0a,0x00,0xff,
2620 0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x4c,0x01,0x00,
2621 0x21,0xf9,0x04,0x01,0x0a,0x00,0x01,0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
2622 0x00,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 */
2633 static 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
2662 static 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
2670 static 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
2920 static 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
3040 static 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
3116 static 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 stat = GdipBitmapGetPixel(bitmap2, 0, 0, &color);
3188 expect(Ok, stat);
3189 ok(color_match(0x20405060, color, 1), "Expected 20405060, got %.8x\n", color);
3190
3191 stat = GdipBitmapGetPixel(bitmap2, 0, 1, &color);
3192 expect(Ok, stat);
3193 ok(color_match(0x40506070, color, 1), "Expected 40506070, got %.8x\n", color);
3194
3195 stat = GdipBitmapGetPixel(bitmap2, 1, 0, &color);
3196 expect(Ok, stat);
3197 ok(color_match(0x60708090, color, 1), "Expected 60708090, got %.8x\n", color);
3198
3199 stat = GdipBitmapGetPixel(bitmap2, 1, 1, &color);
3200 expect(Ok, stat);
3201 ok(color_match(0xffffffff, color, 1), "Expected ffffffff, got %.8x\n", color);
3202
3203
3204 GdipDeleteGraphics(graphics);
3205 GdipDisposeImage((GpImage*)bitmap1);
3206 GdipDisposeImage((GpImage*)bitmap2);
3207 GdipDisposeImageAttributes(imageattr);
3208 }
3209
3210 static void test_dispose(void)
3211 {
3212 GpStatus stat;
3213 GpImage *image;
3214 char invalid_image[256];
3215
3216 stat = GdipDisposeImage(NULL);
3217 expect(InvalidParameter, stat);
3218
3219 stat = GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB, NULL, (GpBitmap**)&image);
3220 expect(Ok, stat);
3221
3222 stat = GdipDisposeImage(image);
3223 expect(Ok, stat);
3224
3225 stat = GdipDisposeImage(image);
3226 expect(ObjectBusy, stat);
3227
3228 memset(invalid_image, 0, 256);
3229 stat = GdipDisposeImage((GpImage*)invalid_image);
3230 expect(ObjectBusy, stat);
3231 }
3232
3233 static LONG obj_refcount(void *obj)
3234 {
3235 IUnknown_AddRef((IUnknown *)obj);
3236 return IUnknown_Release((IUnknown *)obj);
3237 }
3238
3239 static GpImage *load_image(const BYTE *image_data, UINT image_size, BOOL valid_data, BOOL todo_load)
3240 {
3241 IStream *stream;
3242 HGLOBAL hmem;
3243 BYTE *data;
3244 HRESULT hr;
3245 GpStatus status;
3246 GpImage *image = NULL, *clone;
3247 ImageType image_type;
3248 LONG refcount, old_refcount;
3249
3250 hmem = GlobalAlloc(0, image_size);
3251 data = GlobalLock(hmem);
3252 memcpy(data, image_data, image_size);
3253 GlobalUnlock(hmem);
3254
3255 hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
3256 ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
3257 if (hr != S_OK) return NULL;
3258
3259 refcount = obj_refcount(stream);
3260 ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
3261
3262 status = GdipLoadImageFromStream(stream, &image);
3263 todo_wine_if(todo_load)
3264 if (valid_data)
3265 ok(status == Ok || broken(status == InvalidParameter), /* XP */
3266 "GdipLoadImageFromStream error %d\n", status);
3267 else
3268 ok(status != Ok, "GdipLoadImageFromStream should fail\n");
3269 if (status != Ok)
3270 {
3271 IStream_Release(stream);
3272 return NULL;
3273 }
3274
3275 status = GdipGetImageType(image, &image_type);
3276 ok(status == Ok, "GdipGetImageType error %d\n", status);
3277
3278 refcount = obj_refcount(stream);
3279 if (image_type == ImageTypeBitmap)
3280 ok(refcount > 1, "expected stream refcount > 1, got %d\n", refcount);
3281 else
3282 ok(refcount == 1, "expected stream refcount 1, got %d\n", refcount);
3283 old_refcount = refcount;
3284
3285 status = GdipCloneImage(image, &clone);
3286 ok(status == Ok, "GdipCloneImage error %d\n", status);
3287 refcount = obj_refcount(stream);
3288 ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
3289 status = GdipDisposeImage(clone);
3290 ok(status == Ok, "GdipDisposeImage error %d\n", status);
3291 refcount = obj_refcount(stream);
3292 ok(refcount == old_refcount, "expected stream refcount %d, got %d\n", old_refcount, refcount);
3293
3294 refcount = IStream_Release(stream);
3295 if (image_type == ImageTypeBitmap)
3296 ok(refcount >= 1, "expected stream refcount != 0\n");
3297 else
3298 ok(refcount == 0, "expected stream refcount 0, got %d\n", refcount);
3299
3300 return image;
3301 }
3302
3303 static void test_image_properties(void)
3304 {
3305 static const struct test_data
3306 {
3307 const BYTE *image_data;
3308 UINT image_size;
3309 ImageType image_type;
3310 UINT prop_count;
3311 UINT prop_count2; /* if win7 behaves differently */
3312 /* 1st property attributes */
3313 UINT prop_size;
3314 UINT prop_size2; /* if win7 behaves differently */
3315 UINT prop_id;
3316 UINT prop_id2; /* if win7 behaves differently */
3317 }
3318 td[] =
3319 {
3320 { pngimage, sizeof(pngimage), ImageTypeBitmap, 4, ~0, 1, 20, 0x5110, 0x132 },
3321 { jpgimage, sizeof(jpgimage), ImageTypeBitmap, 2, ~0, 128, 0, 0x5090, 0x5091 },
3322 { tiffimage, sizeof(tiffimage), ImageTypeBitmap, 16, 0, 4, 0, 0xfe, 0 },
3323 { bmpimage, sizeof(bmpimage), ImageTypeBitmap, 0, 0, 0, 0, 0, 0 },
3324 { wmfimage, sizeof(wmfimage), ImageTypeMetafile, 0, 0, 0, 0, 0, 0 }
3325 };
3326 GpStatus status;
3327 GpImage *image;
3328 UINT prop_count, prop_size, i;
3329 PROPID prop_id[16] = { 0 };
3330 ImageType image_type;
3331 union
3332 {
3333 PropertyItem data;
3334 char buf[256];
3335 } item;
3336
3337 for (i = 0; i < ARRAY_SIZE(td); i++)
3338 {
3339 image = load_image(td[i].image_data, td[i].image_size, TRUE, FALSE);
3340 if (!image)
3341 {
3342 trace("%u: failed to load image data\n", i);
3343 continue;
3344 }
3345
3346 status = GdipGetImageType(image, &image_type);
3347 ok(status == Ok, "%u: GdipGetImageType error %d\n", i, status);
3348 ok(td[i].image_type == image_type, "%u: expected image_type %d, got %d\n",
3349 i, td[i].image_type, image_type);
3350
3351 status = GdipGetPropertyCount(image, &prop_count);
3352 ok(status == Ok, "%u: GdipGetPropertyCount error %d\n", i, status);
3353 todo_wine_if(td[i].image_data == pngimage || td[i].image_data == jpgimage)
3354 ok(td[i].prop_count == prop_count || td[i].prop_count2 == prop_count,
3355 " %u: expected property count %u or %u, got %u\n",
3356 i, td[i].prop_count, td[i].prop_count2, prop_count);
3357
3358 status = GdipGetPropertyItemSize(NULL, 0, &prop_size);
3359 expect(InvalidParameter, status);
3360 status = GdipGetPropertyItemSize(image, 0, NULL);
3361 expect(InvalidParameter, status);
3362 status = GdipGetPropertyItemSize(image, 0, &prop_size);
3363 if (image_type == ImageTypeMetafile)
3364 expect(NotImplemented, status);
3365 else
3366 expect(PropertyNotFound, status);
3367
3368 status = GdipGetPropertyItem(NULL, 0, 0, &item.data);
3369 expect(InvalidParameter, status);
3370 status = GdipGetPropertyItem(image, 0, 0, NULL);
3371 expect(InvalidParameter, status);
3372 status = GdipGetPropertyItem(image, 0, 0, &item.data);
3373 if (image_type == ImageTypeMetafile)
3374 expect(NotImplemented, status);
3375 else
3376 expect(PropertyNotFound, status);
3377
3378 /* FIXME: remove once Wine is fixed */
3379 if (td[i].prop_count != prop_count)
3380 {
3381 GdipDisposeImage(image);
3382 continue;
3383 }
3384
3385 status = GdipGetPropertyIdList(NULL, prop_count, prop_id);
3386 expect(InvalidParameter, status);
3387 status = GdipGetPropertyIdList(image, prop_count, NULL);
3388 expect(InvalidParameter, status);
3389 status = GdipGetPropertyIdList(image, 0, prop_id);
3390 if (image_type == ImageTypeMetafile)
3391 expect(NotImplemented, status);
3392 else if (prop_count == 0)
3393 expect(Ok, status);
3394 else
3395 expect(InvalidParameter, status);
3396 status = GdipGetPropertyIdList(image, prop_count - 1, prop_id);
3397 if (image_type == ImageTypeMetafile)
3398 expect(NotImplemented, status);
3399 else
3400 expect(InvalidParameter, status);
3401 status = GdipGetPropertyIdList(image, prop_count + 1, prop_id);
3402 if (image_type == ImageTypeMetafile)
3403 expect(NotImplemented, status);
3404 else
3405 expect(InvalidParameter, status);
3406 status = GdipGetPropertyIdList(image, prop_count, prop_id);
3407 if (image_type == ImageTypeMetafile)
3408 expect(NotImplemented, status);
3409 else
3410 {
3411 expect(Ok, status);
3412 if (prop_count != 0)
3413 ok(td[i].prop_id == prop_id[0] || td[i].prop_id2 == prop_id[0],
3414 " %u: expected property id %#x or %#x, got %#x\n",
3415 i, td[i].prop_id, td[i].prop_id2, prop_id[0]);
3416 }
3417
3418 if (status == Ok)
3419 {
3420 status = GdipGetPropertyItemSize(image, prop_id[0], &prop_size);
3421 if (prop_count == 0)
3422 expect(PropertyNotFound, status);
3423 else
3424 {
3425 expect(Ok, status);
3426
3427 assert(sizeof(item) >= prop_size);
3428 ok(prop_size > sizeof(PropertyItem), "%u: got too small prop_size %u\n",
3429 i, prop_size);
3430 ok(td[i].prop_size + sizeof(PropertyItem) == prop_size ||
3431 td[i].prop_size2 + sizeof(PropertyItem) == prop_size,
3432 " %u: expected property size %u or %u, got %u\n",
3433 i, td[i].prop_size, td[i].prop_size2, prop_size);
3434
3435 status = GdipGetPropertyItem(image, prop_id[0], 0, &item.data);
3436 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3437 "%u: expected InvalidParameter, got %d\n", i, status);
3438 status = GdipGetPropertyItem(image, prop_id[0], prop_size - 1, &item.data);
3439 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3440 "%u: expected InvalidParameter, got %d\n", i, status);
3441 status = GdipGetPropertyItem(image, prop_id[0], prop_size + 1, &item.data);
3442 ok(status == InvalidParameter || status == GenericError /* Win7 */,
3443 "%u: expected InvalidParameter, got %d\n", i, status);
3444 status = GdipGetPropertyItem(image, prop_id[0], prop_size, &item.data);
3445 expect(Ok, status);
3446 ok(prop_id[0] == item.data.id,
3447 "%u: expected property id %#x, got %#x\n", i, prop_id[0], item.data.id);
3448 }
3449 }
3450
3451 GdipDisposeImage(image);
3452 }
3453 }
3454
3455 #define IFD_BYTE 1
3456 #define IFD_ASCII 2
3457 #define IFD_SHORT 3
3458 #define IFD_LONG 4
3459 #define IFD_RATIONAL 5
3460 #define IFD_SBYTE 6
3461 #define IFD_UNDEFINED 7
3462 #define IFD_SSHORT 8
3463 #define IFD_SLONG 9
3464 #define IFD_SRATIONAL 10
3465 #define IFD_FLOAT 11
3466 #define IFD_DOUBLE 12
3467
3468 #ifndef PropertyTagTypeSByte
3469 #define PropertyTagTypeSByte 6
3470 #define PropertyTagTypeSShort 8
3471 #define PropertyTagTypeFloat 11
3472 #define PropertyTagTypeDouble 12
3473 #endif
3474
3475 static UINT documented_type(UINT type)
3476 {
3477 switch (type)
3478 {
3479 case PropertyTagTypeSByte: return PropertyTagTypeByte;
3480 case PropertyTagTypeSShort: return PropertyTagTypeShort;
3481 case PropertyTagTypeFloat: return PropertyTagTypeUndefined;
3482 case PropertyTagTypeDouble: return PropertyTagTypeUndefined;
3483 default: return type;
3484 }
3485 }
3486
3487 #include "pshpack2.h"
3488 struct IFD_entry
3489 {
3490 SHORT id;
3491 SHORT type;
3492 ULONG count;
3493 LONG value;
3494 };
3495
3496 struct IFD_rational
3497 {
3498 LONG numerator;
3499 LONG denominator;
3500 };
3501
3502 static const struct tiff_data
3503 {
3504 USHORT byte_order;
3505 USHORT version;
3506 ULONG dir_offset;
3507 USHORT number_of_entries;
3508 struct IFD_entry entry[40];
3509 ULONG next_IFD;
3510 struct IFD_rational xres;
3511 DOUBLE double_val;
3512 struct IFD_rational srational_val;
3513 char string[14];
3514 SHORT short_val[4];
3515 LONG long_val[2];
3516 FLOAT float_val[2];
3517 struct IFD_rational rational[3];
3518 BYTE pixel_data[4];
3519 } TIFF_data =
3520 {
3521 #ifdef WORDS_BIGENDIAN
3522 'M' | 'M' << 8,
3523 #else
3524 'I' | 'I' << 8,
3525 #endif
3526 42,
3527 FIELD_OFFSET(struct tiff_data, number_of_entries),
3528 31,
3529 {
3530 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
3531 { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
3532 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
3533 { 0x102, IFD_SHORT, 1, 1 }, /* BITSPERSAMPLE */
3534 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
3535 { 0x106, IFD_SHORT, 1, 1 }, /* PHOTOMETRIC */
3536 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_data, pixel_data) }, /* STRIPOFFSETS */
3537 { 0x115, IFD_SHORT, 1, 1 }, /* SAMPLESPERPIXEL */
3538 { 0x116, IFD_LONG, 1, 1 }, /* ROWSPERSTRIP */
3539 { 0x117, IFD_LONG, 1, 1 }, /* STRIPBYTECOUNT */
3540 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_data, xres) },
3541 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_data, xres) },
3542 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
3543 { 0xf001, IFD_BYTE, 1, 0x11223344 },
3544 { 0xf002, IFD_BYTE, 4, 0x11223344 },
3545 { 0xf003, IFD_SBYTE, 1, 0x11223344 },
3546 { 0xf004, IFD_SSHORT, 1, 0x11223344 },
3547 { 0xf005, IFD_SSHORT, 2, 0x11223344 },
3548 { 0xf006, IFD_SLONG, 1, 0x11223344 },
3549 { 0xf007, IFD_FLOAT, 1, 0x11223344 },
3550 { 0xf008, IFD_DOUBLE, 1, FIELD_OFFSET(struct tiff_data, double_val) },
3551 { 0xf009, IFD_SRATIONAL, 1, FIELD_OFFSET(struct tiff_data, srational_val) },
3552 { 0xf00a, IFD_BYTE, 13, FIELD_OFFSET(struct tiff_data, string) },
3553 { 0xf00b, IFD_SSHORT, 4, FIELD_OFFSET(struct tiff_data, short_val) },
3554 { 0xf00c, IFD_SLONG, 2, FIELD_OFFSET(struct tiff_data, long_val) },
3555 { 0xf00e, IFD_ASCII, 13, FIELD_OFFSET(struct tiff_data, string) },
3556 { 0xf00f, IFD_ASCII, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
3557 { 0xf010, IFD_UNDEFINED, 13, FIELD_OFFSET(struct tiff_data, string) },
3558 { 0xf011, IFD_UNDEFINED, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
3559 /* Some gdiplus versions ignore these fields.
3560 { 0xf012, IFD_BYTE, 0, 0x11223344 },
3561 { 0xf013, IFD_SHORT, 0, 0x11223344 },
3562 { 0xf014, IFD_LONG, 0, 0x11223344 },
3563 { 0xf015, IFD_FLOAT, 0, 0x11223344 },*/
3564 { 0xf016, IFD_SRATIONAL, 3, FIELD_OFFSET(struct tiff_data, rational) },
3565 /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3566 { 0xf017, IFD_FLOAT, 2, FIELD_OFFSET(struct tiff_data, float_val) },
3567 },
3568 0,
3569 { 900, 3 },
3570 1234567890.0987654321,
3571 { 0x1a2b3c4d, 0x5a6b7c8d },
3572 "Hello World!",
3573 { 0x0101, 0x0202, 0x0303, 0x0404 },
3574 { 0x11223344, 0x55667788 },
3575 { (FLOAT)1234.5678, (FLOAT)8765.4321 },
3576 { { 0x01020304, 0x05060708 }, { 0x10203040, 0x50607080 }, { 0x11223344, 0x55667788 } },
3577 { 0x11, 0x22, 0x33, 0 }
3578 };
3579 #include "poppack.h"
3580
3581 static void test_tiff_properties(void)
3582 {
3583 static const struct test_data
3584 {
3585 ULONG type, id, length;
3586 const BYTE value[24];
3587 } td[31] =
3588 {
3589 { PropertyTagTypeShort, 0xff, 2, { 0 } },
3590 { PropertyTagTypeLong, 0x100, 4, { 1 } },
3591 { PropertyTagTypeLong, 0x101, 4, { 1 } },
3592 { PropertyTagTypeShort, 0x102, 2, { 1 } },
3593 { PropertyTagTypeShort, 0x103, 2, { 1 } },
3594 { PropertyTagTypeShort, 0x106, 2, { 1 } },
3595 { PropertyTagTypeLong, 0x111, 4, { 0x44,0x02 } },
3596 { PropertyTagTypeShort, 0x115, 2, { 1 } },
3597 { PropertyTagTypeLong, 0x116, 4, { 1 } },
3598 { PropertyTagTypeLong, 0x117, 4, { 1 } },
3599 { PropertyTagTypeRational, 0x11a, 8, { 0x84,0x03,0,0,0x03 } },
3600 { PropertyTagTypeRational, 0x11b, 8, { 0x84,0x03,0,0,0x03 } },
3601 { PropertyTagTypeShort, 0x128, 2, { 2 } },
3602 { PropertyTagTypeByte, 0xf001, 1, { 0x44 } },
3603 { PropertyTagTypeByte, 0xf002, 4, { 0x44,0x33,0x22,0x11 } },
3604 { PropertyTagTypeSByte, 0xf003, 1, { 0x44 } },
3605 { PropertyTagTypeSShort, 0xf004, 2, { 0x44,0x33 } },
3606 { PropertyTagTypeSShort, 0xf005, 4, { 0x44,0x33,0x22,0x11 } },
3607 { PropertyTagTypeSLONG, 0xf006, 4, { 0x44,0x33,0x22,0x11 } },
3608 { PropertyTagTypeFloat, 0xf007, 4, { 0x44,0x33,0x22,0x11 } },
3609 { PropertyTagTypeDouble, 0xf008, 8, { 0x2c,0x52,0x86,0xb4,0x80,0x65,0xd2,0x41 } },
3610 { PropertyTagTypeSRational, 0xf009, 8, { 0x4d, 0x3c, 0x2b, 0x1a, 0x8d, 0x7c, 0x6b, 0x5a } },
3611 { PropertyTagTypeByte, 0xf00a, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3612 { PropertyTagTypeSShort, 0xf00b, 8, { 0x01,0x01,0x02,0x02,0x03,0x03,0x04,0x04 } },
3613 { PropertyTagTypeSLONG, 0xf00c, 8, { 0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3614 { PropertyTagTypeASCII, 0xf00e, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3615 { PropertyTagTypeASCII, 0xf00f, 5, { 'a','b','c','d' } },
3616 { PropertyTagTypeUndefined, 0xf010, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3617 { PropertyTagTypeUndefined, 0xf011, 4, { 'a','b','c','d' } },
3618 { PropertyTagTypeSRational, 0xf016, 24,
3619 { 0x04,0x03,0x02,0x01,0x08,0x07,0x06,0x05,
3620 0x40,0x30,0x20,0x10,0x80,0x70,0x60,0x50,
3621 0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3622 /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3623 { PropertyTagTypeFloat, 0xf017, 8, { 0x2b,0x52,0x9a,0x44,0xba,0xf5,0x08,0x46 } },
3624 };
3625 GpStatus status;
3626 GpImage *image;
3627 GUID guid;
3628 UINT dim_count, frame_count, prop_count, prop_size, i;
3629 PROPID *prop_id;
3630 PropertyItem *prop_item;
3631
3632 image = load_image((const BYTE *)&TIFF_data, sizeof(TIFF_data), TRUE, FALSE);
3633 if (!image)
3634 {
3635 win_skip("Failed to load TIFF image data. Might not be supported. Skipping.\n");
3636 return;
3637 }
3638
3639 status = GdipImageGetFrameDimensionsCount(image, &dim_count);
3640 expect(Ok, status);
3641 expect(1, dim_count);
3642
3643 status = GdipImageGetFrameDimensionsList(image, &guid, 1);
3644 expect(Ok, status);
3645 expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
3646
3647 frame_count = 0xdeadbeef;
3648 status = GdipImageGetFrameCount(image, &guid, &frame_count);
3649 expect(Ok, status);
3650 expect(1, frame_count);
3651
3652 prop_count = 0xdeadbeef;
3653 status = GdipGetPropertyCount(image, &prop_count);
3654 expect(Ok, status);
3655 ok(prop_count == ARRAY_SIZE(td) ||
3656 broken(prop_count == ARRAY_SIZE(td) - 1) /* Win7 SP0 */,
3657 "expected property count %u, got %u\n", (UINT) ARRAY_SIZE(td), prop_count);
3658
3659 prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
3660
3661 status = GdipGetPropertyIdList(image, prop_count, prop_id);
3662 expect(Ok, status);
3663
3664 for (i = 0; i < prop_count; i++)
3665 {
3666 status = GdipGetPropertyItemSize(image, prop_id[i], &prop_size);
3667 expect(Ok, status);
3668 if (status != Ok) break;
3669 ok(prop_size > sizeof(*prop_item), "%u: too small item length %u\n", i, prop_size);
3670
3671 prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, prop_size);
3672 status = GdipGetPropertyItem(image, prop_id[i], prop_size, prop_item);
3673 expect(Ok, status);
3674 ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
3675 ok(td[i].type == prop_item->type ||
3676 /* Win7 stopped using proper but not documented types, and it
3677 looks broken since TypeFloat and TypeDouble now reported as
3678 TypeUndefined, and signed types reported as unsigned. */
3679 broken(prop_item->type == documented_type(td[i].type)),
3680 "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
3681 ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
3682 prop_size -= sizeof(*prop_item);
3683 ok(prop_item->length == prop_size, "%u: expected length %u, got %u\n", i, prop_size, prop_item->length);
3684 ok(td[i].length == prop_item->length || broken(td[i].id == 0xf00f && td[i].length == prop_item->length+1) /* XP */,
3685 "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
3686 ok(td[i].length == prop_size || broken(td[i].id == 0xf00f && td[i].length == prop_size+1) /* XP */,
3687 "%u: expected length %u, got %u\n", i, td[i].length, prop_size);
3688 if (td[i].length == prop_item->length)
3689 {
3690 int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
3691 ok(match || broken(td[i].length <= 4 && !match), "%u: data mismatch\n", i);
3692 if (!match)
3693 {
3694 UINT j;
3695 BYTE *data = prop_item->value;
3696 trace("id %#x:", prop_item->id);
3697 for (j = 0; j < prop_item->length; j++)
3698 trace(" %02x", data[j]);
3699 trace("\n");
3700 }
3701 }
3702 HeapFree(GetProcessHeap(), 0, prop_item);
3703 }
3704
3705 HeapFree(GetProcessHeap(), 0, prop_id);
3706
3707 GdipDisposeImage(image);
3708 }
3709
3710 static void test_GdipGetAllPropertyItems(void)
3711 {
3712 static const struct test_data
3713 {
3714 ULONG type, id, length;
3715 BYTE value[32];
3716 } td[16] =
3717 {
3718 { PropertyTagTypeLong, 0xfe, 4, { 0 } },
3719 { PropertyTagTypeShort, 0x100, 2, { 1 } },
3720 { PropertyTagTypeShort, 0x101, 2, { 1 } },
3721 { PropertyTagTypeShort, 0x102, 6, { 8,0,8,0,8,0 } },
3722 { PropertyTagTypeShort, 0x103, 2, { 1 } },
3723 { PropertyTagTypeShort, 0x106, 2, { 2,0 } },
3724 { PropertyTagTypeASCII, 0x10d, 27, "/home/meh/Desktop/test.tif" },
3725 { PropertyTagTypeLong, 0x111, 4, { 8,0,0,0 } },
3726 { PropertyTagTypeShort, 0x112, 2, { 1 } },
3727 { PropertyTagTypeShort, 0x115, 2, { 3,0 } },
3728 { PropertyTagTypeShort, 0x116, 2, { 0x40,0 } },
3729 { PropertyTagTypeLong, 0x117, 4, { 3,0,0,0 } },
3730 { PropertyTagTypeRational, 0x11a, 8, { 0,0,0,72,0,0,0,1 } },
3731 { PropertyTagTypeRational, 0x11b, 8, { 0,0,0,72,0,0,0,1 } },
3732 { PropertyTagTypeShort, 0x11c, 2, { 1 } },
3733 { PropertyTagTypeShort, 0x128, 2, { 2 } }
3734 };
3735 GpStatus status;
3736 GpImage *image;
3737 GUID guid;
3738 UINT dim_count, frame_count, prop_count, prop_size, i;
3739 UINT total_size, total_count;
3740 PROPID *prop_id;
3741 PropertyItem *prop_item;
3742 const char *item_data;
3743
3744 image = load_image(tiffimage, sizeof(tiffimage), TRUE, FALSE);
3745 ok(image != 0, "Failed to load TIFF image data\n");
3746 if (!image) return;
3747
3748 dim_count = 0xdeadbeef;
3749 status = GdipImageGetFrameDimensionsCount(image, &dim_count);
3750 expect(Ok, status);
3751 expect(1, dim_count);
3752
3753 status = GdipImageGetFrameDimensionsList(image, &guid, 1);
3754 expect(Ok, status);
3755 expect_guid(&FrameDimensionPage, &guid, __LINE__, FALSE);
3756
3757 frame_count = 0xdeadbeef;
3758 status = GdipImageGetFrameCount(image, &guid, &frame_count);
3759 expect(Ok, status);
3760 expect(1, frame_count);
3761
3762 prop_count = 0xdeadbeef;
3763 status = GdipGetPropertyCount(image, &prop_count);
3764 expect(Ok, status);
3765 ok(prop_count == ARRAY_SIZE(td),
3766 "expected property count %u, got %u\n", (UINT) ARRAY_SIZE(td), prop_count);
3767
3768 prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
3769
3770 status = GdipGetPropertyIdList(image, prop_count, prop_id);
3771 expect(Ok, status);
3772
3773 prop_size = 0;
3774 for (i = 0; i < prop_count; i++)
3775 {
3776 UINT size;
3777 status = GdipGetPropertyItemSize(image, prop_id[i], &size);
3778 expect(Ok, status);
3779 if (status != Ok) break;
3780 ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
3781
3782 prop_size += size;
3783
3784 prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
3785 status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
3786 expect(Ok, status);
3787 ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
3788 ok(td[i].type == prop_item->type,
3789 "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
3790 ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
3791 size -= sizeof(*prop_item);
3792 ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
3793 ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
3794 if (td[i].length == prop_item->length)
3795 {
3796 int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
3797 ok(match, "%u: data mismatch\n", i);
3798 if (!match)
3799 {
3800 UINT j;
3801 BYTE *data = prop_item->value;
3802 trace("id %#x:", prop_item->id);
3803 for (j = 0; j < prop_item->length; j++)
3804 trace(" %02x", data[j]);
3805 trace("\n");
3806 }
3807 }
3808 HeapFree(GetProcessHeap(), 0, prop_item);
3809 }
3810
3811 HeapFree(GetProcessHeap(), 0, prop_id);
3812
3813 status = GdipGetPropertySize(NULL, &total_size, &total_count);
3814 expect(InvalidParameter, status);
3815 status = GdipGetPropertySize(image, &total_size, NULL);
3816 expect(InvalidParameter, status);
3817 status = GdipGetPropertySize(image, NULL, &total_count);
3818 expect(InvalidParameter, status);
3819 status = GdipGetPropertySize(image, NULL, NULL);
3820 expect(InvalidParameter, status);
3821 total_size = 0xdeadbeef;
3822 total_count = 0xdeadbeef;
3823 status = GdipGetPropertySize(image, &total_size, &total_count);
3824 expect(Ok, status);
3825 ok(prop_count == total_count,
3826 "expected total property count %u, got %u\n", prop_count, total_count);
3827 ok(prop_size == total_size,
3828 "expected total property size %u, got %u\n", prop_size, total_size);
3829
3830 prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
3831
3832 status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
3833 expect(InvalidParameter, status);
3834 status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
3835 expect(InvalidParameter, status);
3836 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3837 expect(InvalidParameter, status);
3838 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
3839 expect(InvalidParameter, status);
3840 status = GdipGetAllPropertyItems(image, 0, 0, NULL);
3841 expect(InvalidParameter, status);
3842 status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
3843 expect(InvalidParameter, status);
3844 status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
3845 expect(Ok, status);
3846
3847 item_data = (const char *)(prop_item + prop_count);
3848 for (i = 0; i < prop_count; i++)
3849 {
3850 ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
3851 i, item_data, prop_item[i].value);
3852 ok(td[i].type == prop_item[i].type,
3853 "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
3854 ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
3855 ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
3856 if (td[i].length == prop_item[i].length)
3857 {
3858 int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
3859 ok(match, "%u: data mismatch\n", i);
3860 if (!match)
3861 {
3862 UINT j;
3863 BYTE *data = prop_item[i].value;
3864 trace("id %#x:", prop_item[i].id);
3865 for (j = 0; j < prop_item[i].length; j++)
3866 trace(" %02x", data[j]);
3867 trace("\n");
3868 }
3869 }
3870 item_data += prop_item[i].length;
3871 }
3872
3873 HeapFree(GetProcessHeap(), 0, prop_item);
3874
3875 GdipDisposeImage(image);
3876 }
3877
3878 static void test_tiff_palette(void)
3879 {
3880 GpStatus status;
3881 GpImage *image;
3882 PixelFormat format;
3883 INT size;
3884 struct
3885 {
3886 ColorPalette pal;
3887 ARGB entry[256];
3888 } palette;
3889 ARGB *entries = palette.pal.Entries;
3890
3891 /* 1bpp TIFF without palette */
3892 image = load_image((const BYTE *)&TIFF_data, sizeof(TIFF_data), TRUE, FALSE);
3893 if (!image)
3894 {
3895 win_skip("Failed to load TIFF image data. Might not be supported. Skipping.\n");
3896 return;
3897 }
3898
3899 status = GdipGetImagePixelFormat(image, &format);
3900 expect(Ok, status);
3901 ok(format == PixelFormat1bppIndexed, "expected PixelFormat1bppIndexed, got %#x\n", format);
3902
3903 status = GdipGetImagePaletteSize(image, &size);
3904 ok(status == Ok || broken(status == GenericError), /* XP */
3905 "GdipGetImagePaletteSize error %d\n", status);
3906 if (status == GenericError)
3907 {
3908 GdipDisposeImage(image);
3909 return;
3910 }
3911 expect(sizeof(ColorPalette) + sizeof(ARGB), size);
3912
3913 status = GdipGetImagePalette(image, &palette.pal, size);
3914 expect(Ok, status);
3915 expect(0, palette.pal.Flags);
3916 expect(2, palette.pal.Count);
3917 if (palette.pal.Count == 2)
3918 {
3919 ok(entries[0] == 0xff000000, "expected 0xff000000, got %#x\n", entries[0]);
3920 ok(entries[1] == 0xffffffff, "expected 0xffffffff, got %#x\n", entries[1]);
3921 }
3922
3923 GdipDisposeImage(image);
3924 }
3925
3926 static void test_bitmapbits(void)
3927 {
3928 /* 8 x 2 bitmap */
3929 static const BYTE pixels_24[48] =
3930 {
3931 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3932 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3933 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3934 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0
3935 };
3936 static const BYTE pixels_00[48] =
3937 {
3938 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3939 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3940 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3941 0,0,0, 0,0,0, 0,0,0, 0,0,0
3942 };
3943 static const BYTE pixels_24_77[64] =
3944 {
3945 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3946 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3947 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3948 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3949 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3950 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3951 };
3952 static const BYTE pixels_77[64] =
3953 {
3954 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3955 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3956 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3957 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3958 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3959 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3960 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3961 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3962 };
3963 static const BYTE pixels_8[16] =
3964 {
3965 0x01,0,0x01,0,0x01,0,0x01,0,
3966 0x01,0,0x01,0,0x01,0,0x01,0
3967 };
3968 static const BYTE pixels_8_77[64] =
3969 {
3970 0x01,0,0x01,0,0x01,0,0x01,0,
3971 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3972 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3973 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3974 0x01,0,0x01,0,0x01,0,0x01,0,
3975 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3976 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3977 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3978 };
3979 static const BYTE pixels_1_77[64] =
3980 {
3981 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3982 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3983 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3984 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3985 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3986 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3987 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3988 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3989 };
3990 static const BYTE pixels_1[8] = {0xaa,0,0,0,0xaa,0,0,0};
3991 static const struct test_data
3992 {
3993 PixelFormat format;
3994 UINT bpp;
3995 ImageLockMode mode;
3996 UINT stride, size;
3997 const BYTE *pixels;
3998 const BYTE *pixels_unlocked;
3999 } td[] =
4000 {
4001 /* 0 */
4002 { PixelFormat24bppRGB, 24, 0xfff0, 24, 48, pixels_24, pixels_00 },
4003
4004 { PixelFormat24bppRGB, 24, 0, 24, 48, pixels_24, pixels_00 },
4005 { PixelFormat24bppRGB, 24, ImageLockModeRead, 24, 48, pixels_24, pixels_00 },
4006 { PixelFormat24bppRGB, 24, ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
4007 { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeWrite, 24, 48, pixels_24, pixels_00 },
4008 { PixelFormat24bppRGB, 24, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_24_77, pixels_24 },
4009 { PixelFormat24bppRGB, 24, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4010 { PixelFormat24bppRGB, 24, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4011 /* 8 */
4012 { PixelFormat8bppIndexed, 8, 0, 8, 16, pixels_8, pixels_24 },
4013 { PixelFormat8bppIndexed, 8, ImageLockModeRead, 8, 16, pixels_8, pixels_24 },
4014 { PixelFormat8bppIndexed, 8, ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
4015 { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeWrite, 8, 16, pixels_8, pixels_00 },
4016 { PixelFormat8bppIndexed, 8, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_8_77, pixels_24 },
4017 { PixelFormat8bppIndexed, 8, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4018 { PixelFormat8bppIndexed, 8, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4019 /* 15 */
4020 { PixelFormat1bppIndexed, 1, 0, 4, 8, pixels_1, pixels_24 },
4021 { PixelFormat1bppIndexed, 1, ImageLockModeRead, 4, 8, pixels_1, pixels_24 },
4022 { PixelFormat1bppIndexed, 1, ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
4023 { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeWrite, 4, 8, pixels_1, pixels_00 },
4024 { PixelFormat1bppIndexed, 1, ImageLockModeRead|ImageLockModeUserInputBuf, 32, 64, pixels_1_77, pixels_24 },
4025 { PixelFormat1bppIndexed, 1, ImageLockModeWrite|ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_00 },
4026 { PixelFormat1bppIndexed, 1, ImageLockModeUserInputBuf, 32, 64, pixels_77, pixels_24 },
4027 };
4028 BYTE buf[64];
4029 GpStatus status;
4030 GpBitmap *bitmap;
4031 UINT i;
4032 BitmapData data;
4033 struct
4034 {
4035 ColorPalette pal;
4036 ARGB entries[1];
4037 } palette;
4038 ARGB *entries = palette.pal.Entries;
4039
4040 for (i = 0; i < ARRAY_SIZE(td); i++)
4041 {
4042 BYTE pixels[sizeof(pixels_24)];
4043 memcpy(pixels, pixels_24, sizeof(pixels_24));
4044 status = GdipCreateBitmapFromScan0(8, 2, 24, PixelFormat24bppRGB, pixels, &bitmap);
4045 expect(Ok, status);
4046
4047 /* associate known palette with pixel data */
4048 palette.pal.Flags = PaletteFlagsGrayScale;
4049 palette.pal.Count = 2;
4050 entries[0] = 0xff000000;
4051 entries[1] = 0xffffffff;
4052 status = GdipSetImagePalette((GpImage *)bitmap, &palette.pal);
4053 expect(Ok, status);
4054
4055 memset(&data, 0xfe, sizeof(data));
4056 if (td[i].mode & ImageLockModeUserInputBuf)
4057 {
4058 memset(buf, 0x77, sizeof(buf));
4059 data.Scan0 = buf;
4060 data.Stride = 32;
4061 }
4062 status = GdipBitmapLockBits(bitmap, NULL, td[i].mode, td[i].format, &data);
4063 ok(status == Ok || broken(status == InvalidParameter) /* XP */, "%u: GdipBitmapLockBits error %d\n", i, status);
4064 if (status != Ok)
4065 {
4066 GdipDisposeImage((GpImage *)bitmap);
4067 continue;
4068 }
4069 ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
4070 ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
4071 ok(td[i].stride == data.Stride, "%u: expected %d, got %d\n", i, td[i].stride, data.Stride);
4072 ok(td[i].format == data.PixelFormat, "%u: expected %d, got %d\n", i, td[i].format, data.PixelFormat);
4073 ok(td[i].size == data.Height * data.Stride, "%u: expected %d, got %d\n", i, td[i].size, data.Height * data.Stride);
4074 if (td[i].mode & ImageLockModeUserInputBuf)
4075 ok(data.Scan0 == buf, "%u: got wrong buffer\n", i);
4076 if (td[i].size == data.Height * data.Stride)
4077 {
4078 UINT j, match, width_bytes = (data.Width * td[i].bpp) / 8;
4079
4080 match = 1;
4081 for (j = 0; j < data.Height; j++)
4082 {
4083 if (memcmp((const BYTE *)data.Scan0 + j * data.Stride, td[i].pixels + j * data.Stride, width_bytes) != 0)
4084 {
4085 match = 0;
4086 break;
4087 }
4088 }
4089 if ((td[i].mode & (ImageLockModeRead|ImageLockModeUserInputBuf)) || td[i].format == PixelFormat24bppRGB)
4090 {
4091 ok(match,
4092 "%u: data should match\n", i);
4093 if (!match)
4094 {
4095 BYTE *bits = data.Scan0;
4096 trace("%u: data mismatch for format %#x:", i, td[i].format);
4097 for (j = 0; j < td[i].size; j++)
4098 trace(" %02x", bits[j]);
4099 trace("\n");
4100 }
4101 }
4102 else
4103 ok(!match, "%u: data shouldn't match\n", i);
4104
4105 memset(data.Scan0, 0, td[i].size);
4106 }
4107
4108 status = GdipBitmapUnlockBits(bitmap, &data);
4109 ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
4110
4111 memset(&data, 0xfe, sizeof(data));
4112 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
4113 ok(status == Ok, "%u: GdipBitmapLockBits error %d\n", i, status);
4114 ok(data.Width == 8, "%u: expected 8, got %d\n", i, data.Width);
4115 ok(data.Height == 2, "%u: expected 2, got %d\n", i, data.Height);
4116 ok(data.Stride == 24, "%u: expected 24, got %d\n", i, data.Stride);
4117 ok(data.PixelFormat == PixelFormat24bppRGB, "%u: got wrong pixel format %d\n", i, data.PixelFormat);
4118 ok(data.Height * data.Stride == 48, "%u: expected 48, got %d\n", i, data.Height * data.Stride);
4119 if (data.Height * data.Stride == 48)
4120 {
4121 int match = memcmp(data.Scan0, td[i].pixels_unlocked, 48) == 0;
4122 ok(match, "%u: data should match\n", i);
4123 if (!match)
4124 {
4125 UINT j;
4126 BYTE *bits = data.Scan0;
4127 trace("%u: data mismatch for format %#x:", i, td[i].format);
4128 for (j = 0; j < 48; j++)
4129 trace(" %02x", bits[j]);
4130 trace("\n");
4131 }
4132 }
4133
4134 status = GdipBitmapUnlockBits(bitmap, &data);
4135 ok(status == Ok, "%u: GdipBitmapUnlockBits error %d\n", i, status);
4136
4137 status = GdipDisposeImage((GpImage *)bitmap);
4138 expect(Ok, status);
4139 }
4140 }
4141
4142 static void test_DrawImage(void)
4143 {
4144 BYTE black_1x1[4] = { 0,0,0,0 };
4145 BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4146 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
4147 BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
4148 0,0,0,0,0,0,0xff,0xff };
4149 GpStatus status;
4150 union
4151 {
4152 GpBitmap *bitmap;
4153 GpImage *image;
4154 } u1, u2;
4155 GpGraphics *graphics;
4156 int match;
4157
4158 status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
4159 expect(Ok, status);
4160 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4161 expect(Ok, status);
4162
4163 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
4164 expect(Ok, status);
4165 status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
4166 expect(Ok, status);
4167 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4168 expect(Ok, status);
4169 status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
4170 expect(Ok, status);
4171
4172 status = GdipDrawImageI(graphics, u1.image, 0, 0);
4173 expect(Ok, status);
4174
4175 match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
4176 ok(match, "data should match\n");
4177 if (!match)
4178 {
4179 UINT i, size = sizeof(white_2x2);
4180 BYTE *bits = white_2x2;
4181 for (i = 0; i < size; i++)
4182 trace(" %02x", bits[i]);
4183 trace("\n");
4184 }
4185
4186 status = GdipDeleteGraphics(graphics);
4187 expect(Ok, status);
4188 status = GdipDisposeImage(u1.image);
4189 expect(Ok, status);
4190 status = GdipDisposeImage(u2.image);
4191 expect(Ok, status);
4192 }
4193
4194 static void test_DrawImage_SourceCopy(void)
4195 {
4196 DWORD dst_pixels[4] = { 0xffffffff, 0xffffffff,
4197 0xffffffff, 0xffffffff };
4198 DWORD src_pixels[4] = { 0, 0xffff0000,
4199 0, 0xff00ff };
4200
4201 GpStatus status;
4202 union
4203 {
4204 GpBitmap *bitmap;
4205 GpImage *image;
4206 } u1, u2;
4207 GpGraphics *graphics;
4208
4209 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)dst_pixels, &u1.bitmap);
4210 expect(Ok, status);
4211
4212 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppARGB, (BYTE*)src_pixels, &u2.bitmap);
4213 expect(Ok, status);
4214 status = GdipGetImageGraphicsContext(u1.image, &graphics);
4215 expect(Ok, status);
4216 status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
4217 expect(Ok, status);
4218
4219 status = GdipSetCompositingMode(graphics, CompositingModeSourceCopy);
4220 expect(Ok, status);
4221
4222 status = GdipDrawImageI(graphics, u2.image, 0, 0);
4223 expect(Ok, status);
4224
4225 todo_wine expect(0, dst_pixels[0]);
4226 expect(0xffff0000, dst_pixels[1]);
4227 todo_wine expect(0, dst_pixels[2]);
4228 todo_wine expect(0, dst_pixels[3]);
4229
4230 status = GdipDeleteGraphics(graphics);
4231 expect(Ok, status);
4232 status = GdipDisposeImage(u1.image);
4233 expect(Ok, status);
4234 status = GdipDisposeImage(u2.image);
4235 expect(Ok, status);
4236 }
4237
4238 static void test_GdipDrawImagePointRect(void)
4239 {
4240 BYTE black_1x1[4] = { 0,0,0,0 };
4241 BYTE white_2x2[16] = { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
4242 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
4243 BYTE black_2x2[16] = { 0,0,0,0,0,0,0xff,0xff,
4244 0,0,0,0,0,0,0xff,0xff };
4245 GpStatus status;
4246 union
4247 {
4248 GpBitmap *bitmap;
4249 GpImage *image;
4250 } u1, u2;
4251 GpGraphics *graphics;
4252 int match;
4253
4254 status = GdipCreateBitmapFromScan0(1, 1, 4, PixelFormat24bppRGB, black_1x1, &u1.bitmap);
4255 expect(Ok, status);
4256 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4257 expect(Ok, status);
4258
4259 status = GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat24bppRGB, white_2x2, &u2.bitmap);
4260 expect(Ok, status);
4261 status = GdipBitmapSetResolution(u2.bitmap, 300.0, 300.0);
4262 expect(Ok, status);
4263 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4264 expect(Ok, status);
4265 status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
4266 expect(Ok, status);
4267
4268 status = GdipDrawImagePointRectI(graphics, u1.image, 0, 0, 0, 0, 1, 1, UnitPixel);
4269 expect(Ok, status);
4270
4271 match = memcmp(white_2x2, black_2x2, sizeof(black_2x2)) == 0;
4272 ok(match, "data should match\n");
4273 if (!match)
4274 {
4275 UINT i, size = sizeof(white_2x2);
4276 BYTE *bits = white_2x2;
4277 for (i = 0; i < size; i++)
4278 trace(" %02x", bits[i]);
4279 trace("\n");
4280 }
4281
4282 status = GdipDeleteGraphics(graphics);
4283 expect(Ok, status);
4284 status = GdipDisposeImage(u1.image);
4285 expect(Ok, status);
4286 status = GdipDisposeImage(u2.image);
4287 expect(Ok, status);
4288 }
4289
4290 static void test_image_format(void)
4291 {
4292 static const PixelFormat fmt[] =
4293 {
4294 PixelFormat1bppIndexed, PixelFormat4bppIndexed, PixelFormat8bppIndexed,
4295 PixelFormat16bppGrayScale, PixelFormat16bppRGB555, PixelFormat16bppRGB565,
4296 PixelFormat16bppARGB1555, PixelFormat24bppRGB, PixelFormat32bppRGB,
4297 PixelFormat32bppARGB, PixelFormat32bppPARGB, PixelFormat48bppRGB,
4298 PixelFormat64bppARGB, PixelFormat64bppPARGB, PixelFormat32bppCMYK
4299 };
4300 GpStatus status;
4301 GpBitmap *bitmap;
4302 GpImage *thumb;
4303 HBITMAP hbitmap;
4304 BITMAP bm;
4305 PixelFormat format;
4306 BitmapData data;
4307 UINT i, ret;
4308
4309 for (i = 0; i < ARRAY_SIZE(fmt); i++)
4310 {
4311 status = GdipCreateBitmapFromScan0(1, 1, 0, fmt[i], NULL, &bitmap);
4312 ok(status == Ok || broken(status == InvalidParameter) /* before win7 */,
4313 "GdipCreateBitmapFromScan0 error %d\n", status);
4314 if (status != Ok) continue;
4315
4316 status = GdipGetImagePixelFormat((GpImage *)bitmap, &format);
4317 expect(Ok, status);
4318 expect(fmt[i], format);
4319
4320 status = GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
4321 if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
4322 todo_wine expect(InvalidParameter, status);
4323 else
4324 {
4325 expect(Ok, status);
4326 ret = GetObjectW(hbitmap, sizeof(bm), &bm);
4327 expect(sizeof(bm), ret);
4328 expect(0, bm.bmType);
4329 expect(1, bm.bmWidth);
4330 expect(1, bm.bmHeight);
4331 expect(4, bm.bmWidthBytes);
4332 expect(1, bm.bmPlanes);
4333 expect(32, bm.bmBitsPixel);
4334 DeleteObject(hbitmap);
4335 }
4336
4337 status = GdipGetImageThumbnail((GpImage *)bitmap, 0, 0, &thumb, NULL, NULL);
4338 if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
4339 todo_wine
4340 ok(status == OutOfMemory || broken(status == InvalidParameter) /* before win7 */,
4341 "expected OutOfMemory, got %d\n", status);
4342 else
4343 expect(Ok, status);
4344 if (status == Ok)
4345 {
4346 status = GdipGetImagePixelFormat(thumb, &format);
4347 expect(Ok, status);
4348 ok(format == PixelFormat32bppPARGB || broken(format != PixelFormat32bppPARGB) /* before win7 */,
4349 "expected PixelFormat32bppPARGB, got %#x\n", format);
4350 status = GdipDisposeImage(thumb);
4351 expect(Ok, status);
4352 }
4353
4354 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppPARGB, &data);
4355 if (fmt[i] == PixelFormat16bppGrayScale || fmt[i] == PixelFormat32bppCMYK)
4356 todo_wine expect(InvalidParameter, status);
4357 else
4358 {
4359 expect(Ok, status);
4360 status = GdipBitmapUnlockBits(bitmap, &data);
4361 expect(Ok, status);
4362 }
4363
4364 status = GdipDisposeImage((GpImage *)bitmap);
4365 expect(Ok, status);
4366 }
4367 }
4368
4369 static void test_DrawImage_scale(void)
4370 {
4371 static const BYTE back_8x1[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
4372 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4373 static const BYTE image_080[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,
4374 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4375 static const BYTE image_100[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,
4376 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4377 static const BYTE image_120[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x40,0x40,0x40,
4378 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4379 static const BYTE image_150[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4380 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4381 static const BYTE image_180[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4382 0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4383 static const BYTE image_200[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4384 0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4385 static const BYTE image_250[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,
4386 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
4387 static const BYTE image_120_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
4388 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4389 static const BYTE image_150_half[24] = { 0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
4390 0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40 };
4391 static const BYTE image_200_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4392 0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40,0x40,0x40,0x40 };
4393 static const BYTE image_250_half[24] = { 0x40,0x40,0x40,0x40,0x40,0x40,0x80,0x80,0x80,0x80,0x80,0x80,
4394 0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x40,0x40,0x40 };
4395 static const struct test_data
4396 {
4397 REAL scale_x;
4398 PixelOffsetMode pixel_offset_mode;
4399 const BYTE *image;
4400 BOOL todo;
4401 } td[] =
4402 {
4403 { 0.8, PixelOffsetModeNone, image_080 }, /* 0 */
4404 { 1.0, PixelOffsetModeNone, image_100 },
4405 { 1.2, PixelOffsetModeNone, image_120 },
4406 { 1.5, PixelOffsetModeNone, image_150 },
4407 { 1.8, PixelOffsetModeNone, image_180 },
4408 { 2.0, PixelOffsetModeNone, image_200 },
4409 { 2.5, PixelOffsetModeNone, image_250 },
4410
4411 { 0.8, PixelOffsetModeHighSpeed, image_080 }, /* 7 */
4412 { 1.0, PixelOffsetModeHighSpeed, image_100 },
4413 { 1.2, PixelOffsetModeHighSpeed, image_120 },
4414 { 1.5, PixelOffsetModeHighSpeed, image_150 },
4415 { 1.8, PixelOffsetModeHighSpeed, image_180 },
4416 { 2.0, PixelOffsetModeHighSpeed, image_200 },
4417 { 2.5, PixelOffsetModeHighSpeed, image_250 },
4418
4419 { 0.8, PixelOffsetModeHalf, image_080 }, /* 14 */
4420 { 1.0, PixelOffsetModeHalf, image_100 },
4421 { 1.2, PixelOffsetModeHalf, image_120_half, TRUE },
4422 { 1.5, PixelOffsetModeHalf, image_150_half, TRUE },
4423 { 1.8, PixelOffsetModeHalf, image_180 },
4424 { 2.0, PixelOffsetModeHalf, image_200_half, TRUE },
4425 { 2.5, PixelOffsetModeHalf, image_250_half, TRUE },
4426
4427 { 0.8, PixelOffsetModeHighQuality, image_080 }, /* 21 */
4428 { 1.0, PixelOffsetModeHighQuality, image_100 },
4429 { 1.2, PixelOffsetModeHighQuality, image_120_half, TRUE },
4430 { 1.5, PixelOffsetModeHighQuality, image_150_half, TRUE },
4431 { 1.8, PixelOffsetModeHighQuality, image_180 },
4432 { 2.0, PixelOffsetModeHighQuality, image_200_half, TRUE },
4433 { 2.5, PixelOffsetModeHighQuality, image_250_half, TRUE },
4434 };
4435 BYTE src_2x1[6] = { 0x80,0x80,0x80,0x80,0x80,0x80 };
4436 BYTE dst_8x1[24];
4437 GpStatus status;
4438 union
4439 {
4440 GpBitmap *bitmap;
4441 GpImage *image;
4442 } u1, u2;
4443 GpGraphics *graphics;
4444 GpMatrix *matrix;
4445 int i, match;
4446
4447 status = GdipCreateBitmapFromScan0(2, 1, 4, PixelFormat24bppRGB, src_2x1, &u1.bitmap);
4448 expect(Ok, status);
4449 status = GdipBitmapSetResolution(u1.bitmap, 100.0, 100.0);
4450 expect(Ok, status);
4451
4452 status = GdipCreateBitmapFromScan0(8, 1, 24, PixelFormat24bppRGB, dst_8x1, &u2.bitmap);
4453 expect(Ok, status);
4454 status = GdipBitmapSetResolution(u2.bitmap, 100.0, 100.0);
4455 expect(Ok, status);
4456 status = GdipGetImageGraphicsContext(u2.image, &graphics);
4457 expect(Ok, status);
4458 status = GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
4459 expect(Ok, status);
4460
4461 for (i = 0; i < ARRAY_SIZE(td); i++)
4462 {
4463 status = GdipSetPixelOffsetMode(graphics, td[i].pixel_offset_mode);
4464 expect(Ok, status);
4465
4466 status = GdipCreateMatrix2(td[i].scale_x, 0.0, 0.0, 1.0, 0.0, 0.0, &matrix);
4467 expect(Ok, status);
4468 status = GdipSetWorldTransform(graphics, matrix);
4469 expect(Ok, status);
4470 GdipDeleteMatrix(matrix);
4471
4472 memcpy(dst_8x1, back_8x1, sizeof(dst_8x1));
4473 status = GdipDrawImageI(graphics, u1.image, 1, 0);
4474 expect(Ok, status);
4475
4476 match = memcmp(dst_8x1, td[i].image, sizeof(dst_8x1)) == 0;
4477 todo_wine_if (!match && td[i].todo)
4478 ok(match, "%d: data should match\n", i);
4479 if (!match)
4480 {
4481 UINT i, size = sizeof(dst_8x1);
4482 const BYTE *bits = dst_8x1;
4483 for (i = 0; i < size; i++)
4484 trace(" %02x", bits[i]);
4485 trace("\n");
4486 }
4487 }
4488
4489 status = GdipDeleteGraphics(graphics);
4490 expect(Ok, status);
4491 status = GdipDisposeImage(u1.image);
4492 expect(Ok, status);
4493 status = GdipDisposeImage(u2.image);
4494 expect(Ok, status);
4495 }
4496
4497 static const BYTE animatedgif[] = {
4498 'G','I','F','8','9','a',0x01,0x00,0x01,0x00,0xA1,0x02,0x00,
4499 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,
4500 /*0x21,0xFF,0x0B,'A','N','I','M','E','X','T','S','1','.','0',*/
4501 0x21,0xFF,0x0B,'N','E','T','S','C','A','P','E','2','.','0',
4502 0x03,0x01,0x05,0x00,0x00,
4503 0x21,0xFE,0x0C,'H','e','l','l','o',' ','W','o','r','l','d','!',0x00,
4504 0x21,0x01,0x0D,'a','n','i','m','a','t','i','o','n','.','g','i','f',0x00,
4505 0x21,0xF9,0x04,0xff,0x0A,0x00,0x08,0x00,
4506 0x2C,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,
4507 0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,
4508 0x02,0x02,0x4C,0x01,0x00,
4509 0x21,0xFE,0x08,'i','m','a','g','e',' ','#','1',0x00,
4510 0x21,0x01,0x0C,'p','l','a','i','n','t','e','x','t',' ','#','1',0x00,
4511 0x21,0xF9,0x04,0x00,0x14,0x00,0x01,0x00,
4512 0x2C,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x81,
4513 0xb1,0xb2,0xb3,0xb4,0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xbb,0xbc,
4514 0x02,0x02,0x44,0x01,0x00,
4515 0x21,0xFE,0x08,'i','m','a','g','e',' ','#','2',0x00,
4516 0x21,0x01,0x0C,'p','l','a','i','n','t','e','x','t',' ','#','2',0x00,0x3B
4517 };
4518
4519 static void test_gif_properties(void)
4520 {
4521 static const struct test_data
4522 {
4523 ULONG type, id, length;
4524 const BYTE value[13];
4525 } td[] =
4526 {
4527 { PropertyTagTypeLong, PropertyTagFrameDelay, 8, { 10,0,0,0,20,0,0,0 } },
4528 { PropertyTagTypeASCII, PropertyTagExifUserComment, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
4529 { PropertyTagTypeShort, PropertyTagLoopCount, 2, { 5,0 } },
4530 { PropertyTagTypeByte, PropertyTagGlobalPalette, 12, { 0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c } },
4531 { PropertyTagTypeByte, PropertyTagIndexBackground, 1, { 2 } },
4532 { PropertyTagTypeByte, PropertyTagIndexTransparent, 1, { 8 } }
4533 };
4534 GpStatus status;
4535 GpImage *image;
4536 GUID guid;
4537 UINT dim_count, frame_count, prop_count, prop_size, i;
4538 UINT total_size, total_count;
4539 PROPID *prop_id;
4540 PropertyItem *prop_item;
4541 const char *item_data;
4542
4543 image = load_image(animatedgif, sizeof(animatedgif), TRUE, FALSE);
4544 if (!image) /* XP fails to load this GIF image */
4545 {
4546 trace("Failed to load GIF image data\n");
4547 return;
4548 }
4549
4550 status = GdipImageGetFrameDimensionsCount(image, &dim_count);
4551 expect(Ok, status);
4552 expect(1, dim_count);
4553
4554 status = GdipImageGetFrameDimensionsList(image, &guid, 1);
4555 expect(Ok, status);
4556 expect_guid(&FrameDimensionTime, &guid, __LINE__, FALSE);
4557
4558 status = GdipImageGetFrameCount(image, &guid, &frame_count);
4559 expect(Ok, status);
4560 expect(2, frame_count);
4561
4562 status = GdipImageSelectActiveFrame(image, &guid, 1);
4563 expect(Ok, status);
4564
4565 status = GdipGetPropertyCount(image, &prop_count);
4566 expect(Ok, status);
4567 ok(prop_count == ARRAY_SIZE(td) || broken(prop_count == 1) /* before win7 */,
4568 "expected property count %u, got %u\n", (UINT) ARRAY_SIZE(td), prop_count);
4569
4570 if (prop_count != ARRAY_SIZE(td))
4571 {
4572 GdipDisposeImage(image);
4573 return;
4574 }
4575
4576 prop_id = HeapAlloc(GetProcessHeap(), 0, prop_count * sizeof(*prop_id));
4577
4578 status = GdipGetPropertyIdList(image, prop_count, prop_id);
4579 expect(Ok, status);
4580
4581 prop_size = 0;
4582 for (i = 0; i < prop_count; i++)
4583 {
4584 UINT size;
4585 status = GdipGetPropertyItemSize(image, prop_id[i], &size);
4586 expect(Ok, status);
4587 if (status != Ok) break;
4588 ok(size > sizeof(*prop_item), "%u: too small item length %u\n", i, size);
4589
4590 prop_size += size;
4591
4592 prop_item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
4593 status = GdipGetPropertyItem(image, prop_id[i], size, prop_item);
4594 expect(Ok, status);
4595 ok(prop_item->value == prop_item + 1, "expected item->value %p, got %p\n", prop_item + 1, prop_item->value);
4596 ok(td[i].type == prop_item->type,
4597 "%u: expected type %u, got %u\n", i, td[i].type, prop_item->type);
4598 ok(td[i].id == prop_item->id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item->id);
4599 size -= sizeof(*prop_item);
4600 ok(prop_item->length == size, "%u: expected length %u, got %u\n", i, size, prop_item->length);
4601 ok(td[i].length == prop_item->length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item->length);
4602 if (td[i].length == prop_item->length)
4603 {
4604 int match = memcmp(td[i].value, prop_item->value, td[i].length) == 0;
4605 ok(match, "%u: data mismatch\n", i);
4606 if (!match)
4607 {
4608 UINT j;
4609 BYTE *data = prop_item->value;
4610 trace("id %#x:", prop_item->id);
4611 for (j = 0; j < prop_item->length; j++)
4612 trace(" %02x", data[j]);
4613 trace("\n");
4614 }
4615 }
4616 HeapFree(GetProcessHeap(), 0, prop_item);
4617 }
4618
4619 HeapFree(GetProcessHeap(), 0, prop_id);
4620
4621 status = GdipGetPropertySize(NULL, &total_size, &total_count);
4622 expect(InvalidParameter, status);
4623 status = GdipGetPropertySize(image, &total_size, NULL);
4624 expect(InvalidParameter, status);
4625 status = GdipGetPropertySize(image, NULL, &total_count);
4626 expect(InvalidParameter, status);
4627 status = GdipGetPropertySize(image, NULL, NULL);
4628 expect(InvalidParameter, status);
4629 total_size = 0xdeadbeef;
4630 total_count = 0xdeadbeef;
4631 status = GdipGetPropertySize(image, &total_size, &total_count);
4632 expect(Ok, status);
4633 ok(prop_count == total_count,
4634 "expected total property count %u, got %u\n", prop_count, total_count);
4635 ok(prop_size == total_size,
4636 "expected total property size %u, got %u\n", prop_size, total_size);
4637
4638 prop_item = HeapAlloc(GetProcessHeap(), 0, prop_size);
4639
4640 status = GdipGetAllPropertyItems(image, 0, prop_count, prop_item);
4641 expect(InvalidParameter, status);
4642 status = GdipGetAllPropertyItems(image, prop_size, 1, prop_item);
4643 expect(InvalidParameter, status);
4644 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
4645 expect(InvalidParameter, status);
4646 status = GdipGetAllPropertyItems(image, prop_size, prop_count, NULL);
4647 expect(InvalidParameter, status);
4648 status = GdipGetAllPropertyItems(image, 0, 0, NULL);
4649 expect(InvalidParameter, status);
4650 status = GdipGetAllPropertyItems(image, prop_size + 1, prop_count, prop_item);
4651 expect(InvalidParameter, status);
4652 status = GdipGetAllPropertyItems(image, prop_size, prop_count, prop_item);
4653 expect(Ok, status);
4654
4655 item_data = (const char *)(prop_item + prop_count);
4656 for (i = 0; i < prop_count; i++)
4657 {
4658 ok(prop_item[i].value == item_data, "%u: expected value %p, got %p\n",
4659 i, item_data, prop_item[i].value);
4660 ok(td[i].type == prop_item[i].type,
4661 "%u: expected type %u, got %u\n", i, td[i].type, prop_item[i].type);
4662 ok(td[i].id == prop_item[i].id, "%u: expected id %#x, got %#x\n", i, td[i].id, prop_item[i].id);
4663 ok(td[i].length == prop_item[i].length, "%u: expected length %u, got %u\n", i, td[i].length, prop_item[i].length);
4664 if (td[i].length == prop_item[i].length)
4665 {
4666 int match = memcmp(td[i].value, prop_item[i].value, td[i].length) == 0;
4667 ok(match, "%u: data mismatch\n", i);
4668 if (!match)
4669 {
4670 UINT j;
4671 BYTE *data = prop_item[i].value;
4672 trace("id %#x:", prop_item[i].id);
4673 for (j = 0; j < prop_item[i].length; j++)
4674 trace(" %02x", data[j]);
4675 trace("\n");
4676 }
4677 }
4678 item_data += prop_item[i].length;
4679 }
4680
4681 HeapFree(GetProcessHeap(), 0, prop_item);
4682
4683 GdipDisposeImage(image);
4684 }
4685
4686 static void test_ARGB_conversion(void)
4687 {
4688 BYTE argb[8] = { 0x11,0x22,0x33,0x80, 0xff,0xff,0xff,0 };
4689 BYTE pargb[8] = { 0x09,0x11,0x1a,0x80, 0,0,0,0 };
4690 BYTE rgb32_xp[8] = { 0x11,0x22,0x33,0xff, 0xff,0xff,0xff,0xff };
4691 BYTE rgb24[6] = { 0x11,0x22,0x33, 0xff,0xff,0xff };
4692 BYTE *bits;
4693 GpBitmap *bitmap;
4694 BitmapData data;
4695 GpStatus status;
4696 int match;
4697
4698 status = GdipCreateBitmapFromScan0(2, 1, 8, PixelFormat32bppARGB, argb, &bitmap);
4699 expect(Ok, status);
4700
4701 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppPARGB, &data);
4702 expect(Ok, status);
4703 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4704 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4705 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4706 ok(data.PixelFormat == PixelFormat32bppPARGB, "expected PixelFormat32bppPARGB, got %d\n", data.PixelFormat);
4707 match = !memcmp(data.Scan0, pargb, sizeof(pargb));
4708 ok(match, "bits don't match\n");
4709 if (!match)
4710 {
4711 bits = data.Scan0;
4712 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppPARGB,
4713 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4714 }
4715 status = GdipBitmapUnlockBits(bitmap, &data);
4716 expect(Ok, status);
4717
4718 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat32bppRGB, &data);
4719 expect(Ok, status);
4720 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4721 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4722 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4723 ok(data.PixelFormat == PixelFormat32bppRGB, "expected PixelFormat32bppRGB, got %d\n", data.PixelFormat);
4724 match = !memcmp(data.Scan0, argb, sizeof(argb)) ||
4725 !memcmp(data.Scan0, rgb32_xp, sizeof(rgb32_xp));
4726 ok(match, "bits don't match\n");
4727 if (!match)
4728 {
4729 bits = data.Scan0;
4730 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat32bppRGB,
4731 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4732 }
4733 status = GdipBitmapUnlockBits(bitmap, &data);
4734 expect(Ok, status);
4735
4736 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
4737 expect(Ok, status);
4738 ok(data.Width == 2, "expected 2, got %d\n", data.Width);
4739 ok(data.Height == 1, "expected 1, got %d\n", data.Height);
4740 ok(data.Stride == 8, "expected 8, got %d\n", data.Stride);
4741 ok(data.PixelFormat == PixelFormat24bppRGB, "expected PixelFormat24bppRGB, got %d\n", data.PixelFormat);
4742 match = !memcmp(data.Scan0, rgb24, sizeof(rgb24));
4743 ok(match, "bits don't match\n");
4744 if (!match)
4745 {
4746 bits = data.Scan0;
4747 trace("format %#x, bits %02x,%02x,%02x,%02x %02x,%02x,%02x,%02x\n", PixelFormat24bppRGB,
4748 bits[0], bits[1], bits[2], bits[3], bits[4], bits[5], bits[6], bits[7]);
4749 }
4750 status = GdipBitmapUnlockBits(bitmap, &data);
4751 expect(Ok, status);
4752
4753 GdipDisposeImage((GpImage *)bitmap);
4754 }
4755
4756
4757 static void test_CloneBitmapArea(void)
4758 {
4759 GpStatus status;
4760 GpBitmap *bitmap, *copy;
4761 BitmapData data, data2;
4762
4763 status = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat24bppRGB, NULL, &bitmap);
4764 expect(Ok, status);
4765
4766 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead | ImageLockModeWrite, PixelFormat24bppRGB, &data);
4767 expect(Ok, status);
4768
4769 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data2);
4770 expect(WrongState, status);
4771
4772 status = GdipCloneBitmapAreaI(0, 0, 1, 1, PixelFormat24bppRGB, bitmap, &copy);
4773 expect(Ok, status);
4774
4775 status = GdipBitmapUnlockBits(bitmap, &data);
4776 expect(Ok, status);
4777
4778 GdipDisposeImage((GpImage *)copy);
4779 GdipDisposeImage((GpImage *)bitmap);
4780 }
4781
4782 static BOOL get_encoder_clsid(LPCWSTR mime, GUID *format, CLSID *clsid)
4783 {
4784 GpStatus status;
4785 UINT n_codecs, info_size, i;
4786 ImageCodecInfo *info;
4787 BOOL ret = FALSE;
4788
4789 status = GdipGetImageEncodersSize(&n_codecs, &info_size);
4790 expect(Ok, status);
4791
4792 info = GdipAlloc(info_size);
4793
4794 status = GdipGetImageEncoders(n_codecs, info_size, info);
4795 expect(Ok, status);
4796
4797 for (i = 0; i < n_codecs; i++)
4798 {
4799 if (!lstrcmpW(info[i].MimeType, mime))
4800 {
4801 *format = info[i].FormatID;
4802 *clsid = info[i].Clsid;
4803 ret = TRUE;
4804 break;
4805 }
4806 }
4807
4808 GdipFree(info);
4809 return ret;
4810 }
4811
4812 static void test_supported_encoders(void)
4813 {
4814 static const WCHAR bmp_mimetype[] = { 'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p',0 };
4815 static const WCHAR jpeg_mimetype[] = { 'i','m','a','g','e','/','j','p','e','g',0 };
4816 static const WCHAR gif_mimetype[] = { 'i','m','a','g','e','/','g','i','f',0 };
4817 static const WCHAR tiff_mimetype[] = { 'i','m','a','g','e','/','t','i','f','f',0 };
4818 static const WCHAR png_mimetype[] = { 'i','m','a','g','e','/','p','n','g',0 };
4819 static const struct test_data
4820 {
4821 LPCWSTR mime;
4822 const GUID *format;
4823 } td[] =
4824 {
4825 { bmp_mimetype, &ImageFormatBMP },
4826 { jpeg_mimetype, &ImageFormatJPEG },
4827 { gif_mimetype, &ImageFormatGIF },
4828 { tiff_mimetype, &ImageFormatTIFF },
4829 { png_mimetype, &ImageFormatPNG }
4830 };
4831 GUID format, clsid;
4832 BOOL ret;
4833 HRESULT hr;
4834 GpStatus status;
4835 GpBitmap *bm;
4836 IStream *stream;
4837 HGLOBAL hmem;
4838 int i;
4839
4840 status = GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat24bppRGB, NULL, &bm);
4841 ok(status == Ok, "GdipCreateBitmapFromScan0 error %d\n", status);
4842
4843 for (i = 0; i < ARRAY_SIZE(td); i++)
4844 {
4845 ret = get_encoder_clsid(td[i].mime, &format, &clsid);
4846 ok(ret, "%s encoder is not in the list\n", wine_dbgstr_w(td[i].mime));
4847 expect_guid(td[i].format, &format, __LINE__, FALSE);
4848
4849 hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 16);
4850
4851 hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
4852 ok(hr == S_OK, "CreateStreamOnHGlobal error %#x\n", hr);
4853
4854 status = GdipSaveImageToStream((GpImage *)bm, stream, &clsid, NULL);
4855 ok(status == Ok, "GdipSaveImageToStream error %d\n", status);
4856
4857 IStream_Release(stream);
4858 }
4859
4860 GdipDisposeImage((GpImage *)bm);
4861 }
4862
4863 static void test_createeffect(void)
4864 {
4865 static const GUID noneffect = { 0xcd0c3d4b, 0xe15e, 0x4cf2, { 0x9e, 0xa8, 0x6e, 0x1d, 0x65, 0x48, 0xc5, 0xa5 } };
4866 GpStatus (WINAPI *pGdipCreateEffect)( const GUID guid, CGpEffect **effect);
4867 GpStatus (WINAPI *pGdipDeleteEffect)( CGpEffect *effect);
4868 GpStatus stat;
4869 CGpEffect *effect;
4870 HMODULE mod = GetModuleHandleA("gdiplus.dll");
4871 int i;
4872 const GUID * const effectlist[] =
4873 {&BlurEffectGuid, &SharpenEffectGuid, &ColorMatrixEffectGuid, &ColorLUTEffectGuid,
4874 &BrightnessContrastEffectGuid, &HueSaturationLightnessEffectGuid, &LevelsEffectGuid,
4875 &TintEffectGuid, &ColorBalanceEffectGuid, &RedEyeCorrectionEffectGuid, &ColorCurveEffectGuid};
4876
4877 pGdipCreateEffect = (void*)GetProcAddress( mod, "GdipCreateEffect");
4878 pGdipDeleteEffect = (void*)GetProcAddress( mod, "GdipDeleteEffect");
4879 if(!pGdipCreateEffect || !pGdipDeleteEffect)
4880 {
4881 /* GdipCreateEffect/GdipDeleteEffect was introduced in Windows Vista. */
4882 win_skip("GDIPlus version 1.1 not available\n");
4883 return;
4884 }
4885
4886 stat = pGdipCreateEffect(BlurEffectGuid, NULL);
4887 expect(InvalidParameter, stat);
4888
4889 stat = pGdipCreateEffect(noneffect, &effect);
4890 todo_wine expect(Win32Error, stat);
4891
4892 for(i=0; i < ARRAY_SIZE(effectlist); i++)
4893 {
4894 stat = pGdipCreateEffect(*effectlist[i], &effect);
4895 todo_wine expect(Ok, stat);
4896 if(stat == Ok)
4897 {
4898 stat = pGdipDeleteEffect(effect);
4899 expect(Ok, stat);
4900 }
4901 }
4902 }
4903
4904 static void test_getadjustedpalette(void)
4905 {
4906 ColorMap colormap;
4907 GpImageAttributes *imageattributes;
4908 ColorPalette *palette;
4909 GpStatus stat;
4910
4911 stat = GdipCreateImageAttributes(&imageattributes);
4912 expect(Ok, stat);
4913
4914 colormap.oldColor.Argb = 0xffffff00;
4915 colormap.newColor.Argb = 0xffff00ff;
4916 stat = GdipSetImageAttributesRemapTable(imageattributes, ColorAdjustTypeBitmap,
4917 TRUE, 1, &colormap);
4918 expect(Ok, stat);
4919
4920 colormap.oldColor.Argb = 0xffffff80;
4921 colormap.newColor.Argb = 0xffff80ff;
4922 stat = GdipSetImageAttributesRemapTable(imageattributes, ColorAdjustTypeDefault,
4923 TRUE, 1, &colormap);
4924 expect(Ok, stat);
4925
4926 palette = GdipAlloc(sizeof(*palette) + sizeof(ARGB) * 2);
4927 palette->Count = 0;
4928
4929 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, palette, ColorAdjustTypeBitmap);
4930 expect(InvalidParameter, stat);
4931
4932 palette->Count = 3;
4933 palette->Entries[0] = 0xffffff00;
4934 palette->Entries[1] = 0xffffff80;
4935 palette->Entries[2] = 0xffffffff;
4936
4937 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, palette, ColorAdjustTypeBitmap);
4938 expect(Ok, stat);
4939 expect(0xffff00ff, palette->Entries[0]);
4940 expect(0xffffff80, palette->Entries[1]);
4941 expect(0xffffffff, palette->Entries[2]);
4942
4943 palette->Entries[0] = 0xffffff00;
4944 palette->Entries[1] = 0xffffff80;
4945 palette->Entries[2] = 0xffffffff;
4946
4947 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, palette, ColorAdjustTypeBrush);
4948 expect(Ok, stat);
4949 expect(0xffffff00, palette->Entries[0]);
4950 expect(0xffff80ff, palette->Entries[1]);
4951 expect(0xffffffff, palette->Entries[2]);
4952
4953 stat = GdipGetImageAttributesAdjustedPalette(NULL, palette, ColorAdjustTypeBitmap);
4954 expect(InvalidParameter, stat);
4955
4956 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, NULL, ColorAdjustTypeBitmap);
4957 expect(InvalidParameter, stat);
4958
4959 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, palette, -1);
4960 expect(InvalidParameter, stat);
4961
4962 stat = GdipGetImageAttributesAdjustedPalette(imageattributes, palette, ColorAdjustTypeDefault);
4963 expect(InvalidParameter, stat);
4964
4965 GdipFree(palette);
4966 GdipDisposeImageAttributes(imageattributes);
4967 }
4968
4969 static void test_histogram(void)
4970 {
4971 UINT ch0[256], ch1[256], ch2[256], ch3[256];
4972 HistogramFormat test_formats[] =
4973 {
4974 HistogramFormatARGB,
4975 HistogramFormatPARGB,
4976 HistogramFormatRGB,
4977 HistogramFormatGray,
4978 HistogramFormatB,
4979 HistogramFormatG,
4980 HistogramFormatR,
4981 HistogramFormatA,
4982 };
4983 const UINT WIDTH = 8, HEIGHT = 16;
4984 UINT num, i, x;
4985 GpStatus stat;
4986 GpBitmap *bm;
4987
4988 if (!pGdipBitmapGetHistogramSize)
4989 {
4990 win_skip("GdipBitmapGetHistogramSize is not supported\n");
4991 return;
4992 }
4993
4994 stat = pGdipBitmapGetHistogramSize(HistogramFormatARGB, NULL);
4995 expect(InvalidParameter, stat);
4996
4997 stat = pGdipBitmapGetHistogramSize(0xff, NULL);
4998 expect(InvalidParameter, stat);
4999
5000 num = 123;
5001 stat = pGdipBitmapGetHistogramSize(10, &num);
5002 expect(Ok, stat);
5003 expect(256, num);
5004
5005 for (i = 0; i < ARRAY_SIZE(test_formats); i++)
5006 {
5007 num = 0;
5008 stat = pGdipBitmapGetHistogramSize(test_formats[i], &num);
5009 expect(Ok, stat);
5010 expect(256, num);
5011 }
5012
5013 bm = NULL;
5014 stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
5015 expect(Ok, stat);
5016
5017 /* Three solid rgb rows, next three rows are rgb shades. */
5018 for (x = 0; x < WIDTH; x++)
5019 {
5020 GdipBitmapSetPixel(bm, x, 0, 0xffff0000);
5021 GdipBitmapSetPixel(bm, x, 1, 0xff00ff00);
5022 GdipBitmapSetPixel(bm, x, 2, 0xff0000ff);
5023
5024 GdipBitmapSetPixel(bm, x, 3, 0xff010000);
5025 GdipBitmapSetPixel(bm, x, 4, 0xff003f00);
5026 GdipBitmapSetPixel(bm, x, 5, 0xff000020);
5027 }
5028
5029 stat = pGdipBitmapGetHistogram(NULL, HistogramFormatRGB, 256, ch0, ch1, ch2, ch3);
5030 expect(InvalidParameter, stat);
5031
5032 stat = pGdipBitmapGetHistogram(bm, 123, 256, ch0, ch1, ch2, ch3);
5033 expect(InvalidParameter, stat);
5034
5035 stat = pGdipBitmapGetHistogram(bm, 123, 256, ch0, ch1, ch2, NULL);
5036 expect(InvalidParameter, stat);
5037
5038 stat = pGdipBitmapGetHistogram(bm, 123, 256, ch0, ch1, NULL, NULL);
5039 expect(InvalidParameter, stat);
5040
5041 stat = pGdipBitmapGetHistogram(bm, 123, 256, ch0, NULL, NULL, NULL);
5042 expect(InvalidParameter, stat);
5043
5044 /* Requested format matches bitmap format */
5045 stat = pGdipBitmapGetHistogram(bm, HistogramFormatRGB, 256, ch0, ch1, ch2, ch3);
5046 expect(InvalidParameter, stat);
5047
5048 stat = pGdipBitmapGetHistogram(bm, HistogramFormatRGB, 100, ch0, ch1, ch2, NULL);
5049 expect(InvalidParameter, stat);
5050
5051 stat = pGdipBitmapGetHistogram(bm, HistogramFormatRGB, 257, ch0, ch1, ch2, NULL);
5052 expect(InvalidParameter, stat);
5053
5054 /* Channel 3 is not used, must be NULL */
5055 stat = pGdipBitmapGetHistogram(bm, HistogramFormatRGB, 256, ch0, ch1, ch2, NULL);
5056 expect(Ok, stat);
5057
5058 ok(ch0[0xff] == WIDTH, "Got red (0xff) %u\n", ch0[0xff]);
5059 ok(ch1[0xff] == WIDTH, "Got green (0xff) %u\n", ch1[0xff]);
5060 ok(ch2[0xff] == WIDTH, "Got blue (0xff) %u\n", ch1[0xff]);
5061 ok(ch0[0x01] == WIDTH, "Got red (0x01) %u\n", ch0[0x01]);
5062 ok(ch1[0x3f] == WIDTH, "Got green (0x3f) %u\n", ch1[0x3f]);
5063 ok(ch2[0x20] == WIDTH, "Got blue (0x20) %u\n", ch1[0x20]);
5064
5065 /* ARGB histogram from RGB data. */
5066 stat = pGdipBitmapGetHistogram(bm, HistogramFormatARGB, 256, ch0, ch1, ch2, NULL);
5067 expect(InvalidParameter, stat);
5068
5069 stat = pGdipBitmapGetHistogram(bm, HistogramFormatARGB, 256, ch0, ch1, ch2, ch3);
5070 expect(Ok, stat);
5071
5072 ok(ch1[0xff] == WIDTH, "Got red (0xff) %u\n", ch1[0xff]);
5073 ok(ch2[0xff] == WIDTH, "Got green (0xff) %u\n", ch2[0xff]);
5074 ok(ch3[0xff] == WIDTH, "Got blue (0xff) %u\n", ch3[0xff]);
5075 ok(ch1[0x01] == WIDTH, "Got red (0x01) %u\n", ch1[0x01]);
5076 ok(ch2[0x3f] == WIDTH, "Got green (0x3f) %u\n", ch2[0x3f]);
5077 ok(ch3[0x20] == WIDTH, "Got blue (0x20) %u\n", ch3[0x20]);
5078
5079 ok(ch0[0xff] == WIDTH * HEIGHT, "Got alpha (0xff) %u\n", ch0[0xff]);
5080
5081 /* Request grayscale histogram from RGB bitmap. */
5082 stat = pGdipBitmapGetHistogram(bm, HistogramFormatGray, 256, ch0, ch1, ch2, ch3);
5083 expect(InvalidParameter, stat);
5084
5085 stat = pGdipBitmapGetHistogram(bm, HistogramFormatGray, 256, ch0, ch1, ch2, NULL);
5086 expect(InvalidParameter, stat);
5087
5088 stat = pGdipBitmapGetHistogram(bm, HistogramFormatGray, 256, ch0, ch1, NULL, NULL);
5089 expect(InvalidParameter, stat);
5090
5091 stat = pGdipBitmapGetHistogram(bm, HistogramFormatGray, 256, ch0, NULL, NULL, NULL);
5092 expect(Ok, stat);
5093
5094 GdipDisposeImage((GpImage*)bm);
5095 }
5096
5097 static void test_imageabort(void)
5098 {
5099 GpStatus stat;
5100 GpBitmap *bm;
5101
5102 if (!pGdipImageSetAbort)
5103 {
5104 win_skip("GdipImageSetAbort() is not supported.\n");
5105 return;
5106 }
5107
5108 bm = NULL;
5109 stat = GdipCreateBitmapFromScan0(8, 8, 0, PixelFormat24bppRGB, NULL, &bm);
5110 expect(Ok, stat);
5111
5112 stat = pGdipImageSetAbort(NULL, NULL);
5113 expect(InvalidParameter, stat);
5114
5115 stat = pGdipImageSetAbort((GpImage*)bm, NULL);
5116 expect(Ok, stat);
5117
5118 GdipDisposeImage((GpImage*)bm);
5119 }
5120
5121 /* RGB 24 bpp 1x1 pixel PNG image */
5122 static const char png_1x1_data[] = {
5123 0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a,
5124 0x00,0x00,0x00,0x0d,'I','H','D','R',0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,0xde,
5125 0x00,0x00,0x03,0x00,'P','L','T','E',
5126 0x01,0x01,0x01,0x02,0x02,0x02,0x03,0x03,0x03,0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x06,0x06,0x07,0x07,0x07,0x08,0x08,0x08,
5127 0x09,0x09,0x09,0x0a,0x0a,0x0a,0x0b,0x0b,0x0b,0x0c,0x0c,0x0c,0x0d,0x0d,0x0d,0x0e,0x0e,0x0e,0x0f,0x0f,0x0f,0x10,0x10,0x10,
5128 0x11,0x11,0x11,0x12,0x12,0x12,0x13,0x13,0x13,0x14,0x14,0x14,0x15,0x15,0x15,0x16,0x16,0x16,0x17,0x17,0x17,0x18,0x18,0x18,
5129 0x19,0x19,0x19,0x1a,0x1a,0x1a,0x1b,0x1b,0x1b,0x1c,0x1c,0x1c,0x1d,0x1d,0x1d,0x1e,0x1e,0x1e,0x1f,0x1f,0x1f,0x20,0x20,0x20,
5130 0x21,0x21,0x21,0x22,0x22,0x22,0x23,0x23,0x23,0x24,0x24,0x24,0x25,0x25,0x25,0x26,0x26,0x26,0x27,0x27,0x27,0x28,0x28,0x28,
5131 0x29,0x29,0x29,0x2a,0x2a,0x2a,0x2b,0x2b,0x2b,0x2c,0x2c,0x2c,0x2d,0x2d,0x2d,0x2e,0x2e,0x2e,0x2f,0x2f,0x2f,0x30,0x30,0x30,
5132 0x31,0x31,0x31,0x32,0x32,0x32,0x33,0x33,0x33,0x34,0x34,0x34,0x35,0x35,0x35,0x36,0x36,0x36,0x37,0x37,0x37,0x38,0x38,0x38,
5133 0x39,0x39,0x39,0x3a,0x3a,0x3a,0x3b,0x3b,0x3b,0x3c,0x3c,0x3c,0x3d,0x3d,0x3d,0x3e,0x3e,0x3e,0x3f,0x3f,0x3f,0x40,0x40,0x40,
5134 0x41,0x41,0x41,0x42,0x42,0x42,0x43,0x43,0x43,0x44,0x44,0x44,0x45,0x45,0x45,0x46,0x46,0x46,0x47,0x47,0x47,0x48,0x48,0x48,
5135 0x49,0x49,0x49,0x4a,0x4a,0x4a,0x4b,0x4b,0x4b,0x4c,0x4c,0x4c,0x4d,0x4d,0x4d,0x4e,0x4e,0x4e,0x4f,0x4f,0x4f,0x50,0x50,0x50,
5136 0x51,0x51,0x51,0x52,0x52,0x52,0x53,0x53,0x53,0x54,0x54,0x54,0x55,0x55,0x55,0x56,0x56,0x56,0x57,0x57,0x57,0x58,0x58,0x58,
5137 0x59,0x59,0x59,0x5a,0x5a,0x5a,0x5b,0x5b,0x5b,0x5c,0x5c,0x5c,0x5d,0x5d,0x5d,0x5e,0x5e,0x5e,0x5f,0x5f,0x5f,0x60,0x60,0x60,
5138 0x61,0x61,0x61,0x62,0x62,0x62,0x63,0x63,0x63,0x64,0x64,0x64,0x65,0x65,0x65,0x66,0x66,0x66,0x67,0x67,0x67,0x68,0x68,0x68,
5139 0x69,0x69,0x69,0x6a,0x6a,0x6a,0x6b,0x6b,0x6b,0x6c,0x6c,0x6c,0x6d,0x6d,0x6d,0x6e,0x6e,0x6e,0x6f,0x6f,0x6f,0x70,0x70,0x70,
5140 0x71,0x71,0x71,0x72,0x72,0x72,0x73,0x73,0x73,0x74,0x74,0x74,0x75,0x75,0x75,0x76,0x76,0x76,0x77,0x77,0x77,0x78,0x78,0x78,
5141 0x79,0x79,0x79,0x7a,0x7a,0x7a,0x7b,0x7b,0x7b,0x7c,0x7c,0x7c,0x7d,0x7d,0x7d,0x7e,0x7e,0x7e,0x7f,0x7f,0x7f,0x80,0x80,0x80,
5142 0x01,0x01,0x01,0x02,0x02,0x02,0x03,0x03,0x03,0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x06,0x06,0x07,0x07,0x07,0x08,0x08,0x08,
5143 0x09,0x09,0x09,0x0a,0x0a,0x0a,0x0b,0x0b,0x0b,0x0c,0x0c,0x0c,0x0d,0x0d,0x0d,0x0e,0x0e,0x0e,0x0f,0x0f,0x0f,0x10,0x10,0x10,
5144 0x11,0x11,0x11,0x12,0x12,0x12,0x13,0x13,0x13,0x14,0x14,0x14,0x15,0x15,0x15,0x16,0x16,0x16,0x17,0x17,0x17,0x18,0x18,0x18,
5145 0x19,0x19,0x19,0x1a,0x1a,0x1a,0x1b,0x1b,0x1b,0x1c,0x1c,0x1c,0x1d,0x1d,0x1d,0x1e,0x1e,0x1e,0x1f,0x1f,0x1f,0x20,0x20,0x20,
5146 0x21,0x21,0x21,0x22,0x22,0x22,0x23,0x23,0x23,0x24,0x24,0x24,0x25,0x25,0x25,0x26,0x26,0x26,0x27,0x27,0x27,0x28,0x28,0x28,
5147 0x29,0x29,0x29,0x2a,0x2a,0x2a,0x2b,0x2b,0x2b,0x2c,0x2c,0x2c,0x2d,0x2d,0x2d,0x2e,0x2e,0x2e,0x2f,0x2f,0x2f,0x30,0x30,0x30,
5148 0x31,0x31,0x31,0x32,0x32,0x32,0x33,0x33,0x33,0x34,0x34,0x34,0x35,0x35,0x35,0x36,0x36,0x36,0x37,0x37,0x37,0x38,0x38,0x38,
5149 0x39,0x39,0x39,0x3a,0x3a,0x3a,0x3b,0x3b,0x3b,0x3c,0x3c,0x3c,0x3d,0x3d,0x3d,0x3e,0x3e,0x3e,0x3f,0x3f,0x3f,0x40,0x40,0x40,
5150 0x41,0x41,0x41,0x42,0x42,0x42,0x43,0x43,0x43,0x44,0x44,0x44,0x45,0x45,0x45,0x46,0x46,0x46,0x47,0x47,0x47,0x48,0x48,0x48,
5151 0x49,0x49,0x49,0x4a,0x4a,0x4a,0x4b,0x4b,0x4b,0x4c,0x4c,0x4c,0x4d,0x4d,0x4d,0x4e,0x4e,0x4e,0x4f,0x4f,0x4f,0x50,0x50,0x50,
5152 0x51,0x51,0x51,0x52,0x52,0x52,0x53,0x53,0x53,0x54,0x54,0x54,0x55,0x55,0x55,0x56,0x56,0x56,0x57,0x57,0x57,0x58,0x58,0x58,
5153 0x59,0x59,0x59,0x5a,0x5a,0x5a,0x5b,0x5b,0x5b,0x5c,0x5c,0x5c,0x5d,0x5d,0x5d,0x5e,0x5e,0x5e,0x5f,0x5f,0x5f,0x60,0x60,0x60,
5154 0x61,0x61,0x61,0x62,0x62,0x62,0x63,0x63,0x63,0x64,0x64,0x64,0x65,0x65,0x65,0x66,0x66,0x66,0x67,0x67,0x67,0x68,0x68,0x68,
5155 0x69,0x69,0x69,0x6a,0x6a,0x6a,0x6b,0x6b,0x6b,0x6c,0x6c,0x6c,0x6d,0x6d,0x6d,0x6e,0x6e,0x6e,0x6f,0x6f,0x6f,0x70,0x70,0x70,
5156 0x71,0x71,0x71,0x72,0x72,0x72,0x73,0x73,0x73,0x74,0x74,0x74,0x75,0x75,0x75,0x76,0x76,0x76,0x77,0x77,0x77,0x78,0x78,0x78,
5157 0x79,0x79,0x79,0x7a,0x7a,0x7a,0x7b,0x7b,0x7b,0x7c,0x7c,0x7c,0x7d,0x7d,0x7d,0x7e,0x7e,0x7e,0x7f,0x7f,0x7f,0x80,0x80,0x80,
5158 0x76,0xb6,0x24,0x31,
5159 0x00,0x00,0x00,0x02,'t','R','N','S',0xff,0x00,0xe5,0xb7,0x30,0x4a,
5160 0x00,0x00,0x00,0x0c,'I','D','A','T',0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,0xe7,
5161 0x00,0x00,0x00,0x00,'I','E','N','D',0xae,0x42,0x60,0x82
5162 };
5163
5164 #define PNG_COLOR_TYPE_GRAY 0
5165 #define PNG_COLOR_TYPE_RGB 2
5166 #define PNG_COLOR_TYPE_PALETTE 3
5167 #define PNG_COLOR_TYPE_GRAY_ALPHA 4
5168 #define PNG_COLOR_TYPE_RGB_ALPHA 6
5169
5170 static void test_png_color_formats(void)
5171 {
5172 static const struct
5173 {
5174 char bit_depth, color_type;
5175 struct {
5176 PixelFormat format;
5177 ImageFlags flags;
5178 BOOL todo;
5179 BOOL todo_load;
5180 } t[3];
5181 } td[] =
5182 {
5183 /* 0 */
5184 { 1, PNG_COLOR_TYPE_RGB },
5185 { 2, PNG_COLOR_TYPE_RGB },
5186 { 4, PNG_COLOR_TYPE_RGB },
5187 { 8, PNG_COLOR_TYPE_RGB,
5188 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5189 { PixelFormat24bppRGB, ImageFlagsColorSpaceRGB },
5190 { PixelFormat24bppRGB, ImageFlagsColorSpaceRGB }}},
5191 /* libpng refuses to load our test image complaining about extra compressed data,
5192 * but libpng is still able to load the image with other combination of type/depth
5193 * making RGB 16 bpp case special for some reason. Therefore todo = TRUE.
5194 */
5195 { 16, PNG_COLOR_TYPE_RGB,
5196 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB, TRUE, TRUE },
5197 { PixelFormat32bppARGB, ImageFlagsColorSpaceRGB, TRUE, TRUE },
5198 { PixelFormat32bppARGB, ImageFlagsColorSpaceRGB, TRUE, TRUE }}},
5199
5200 /* 5 */
5201 { 1, PNG_COLOR_TYPE_GRAY,
5202 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5203 { PixelFormat1bppIndexed, ImageFlagsColorSpaceRGB },
5204 { PixelFormat1bppIndexed, ImageFlagsColorSpaceRGB }}},
5205 { 2, PNG_COLOR_TYPE_GRAY,
5206 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5207 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY },
5208 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY }}},
5209 { 4, PNG_COLOR_TYPE_GRAY,
5210 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5211 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY },
5212 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY }}},
5213 { 8, PNG_COLOR_TYPE_GRAY,
5214 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5215 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY },
5216 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY }}},
5217 { 16, PNG_COLOR_TYPE_GRAY,
5218 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5219 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY },
5220 { PixelFormat32bppARGB, ImageFlagsColorSpaceGRAY }}},
5221
5222 /* 10 */
5223 { 1, PNG_COLOR_TYPE_PALETTE,
5224 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5225 { PixelFormat1bppIndexed, ImageFlagsColorSpaceRGB },
5226 { 0, 0 }}},
5227 { 2, PNG_COLOR_TYPE_PALETTE,
5228 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5229 { PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5230 { 0, 0 }}},
5231 { 4, PNG_COLOR_TYPE_PALETTE,
5232 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5233 { PixelFormat4bppIndexed, ImageFlagsColorSpaceRGB },
5234 { 0, 0 }}},
5235 { 8, PNG_COLOR_TYPE_PALETTE,
5236 {{ PixelFormat32bppARGB, ImageFlagsColorSpaceRGB },
5237 { PixelFormat8bppIndexed, ImageFlagsColorSpaceRGB },
5238 { 0, 0 }}},
5239 { 16, PNG_COLOR_TYPE_PALETTE },
5240 };
5241 BYTE buf[sizeof(png_1x1_data)];
5242 GpStatus status;
5243 GpImage *image;
5244 ImageType type;
5245 PixelFormat format;
5246 ImageFlags flags;
5247 BOOL valid;
5248 int i, j, PLTE_off = 0, tRNS_off = 0;
5249 const ImageFlags color_space_mask = ImageFlagsColorSpaceRGB | ImageFlagsColorSpaceCMYK | ImageFlagsColorSpaceGRAY | ImageFlagsColorSpaceYCBCR | ImageFlagsColorSpaceYCCK;
5250
5251 memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
5252 buf[24] = 2;
5253 buf[25] = PNG_COLOR_TYPE_PALETTE;
5254 image = load_image(buf, sizeof(buf), TRUE, FALSE);
5255 status = GdipGetImageFlags(image, &flags);
5256 expect(status, Ok);
5257 ok((flags & color_space_mask) == ImageFlagsColorSpaceRGB || broken(flags == 0x12006) /* before win7 */,
5258 "flags = %#x\n", flags);
5259 if ((flags & color_space_mask) != ImageFlagsColorSpaceRGB) {
5260 GdipDisposeImage(image);
5261 win_skip("broken PNG color space support\n");
5262 return;
5263 }
5264 GdipDisposeImage(image);
5265
5266 for (i = 0; i < sizeof(png_1x1_data) - 4; i++)
5267 {
5268 if (!memcmp(buf + i, "tRNS", 4))
5269 tRNS_off = i;
5270 else if (!memcmp(buf + i, "PLTE", 4))
5271 PLTE_off = i;
5272 }
5273
5274 ok(PLTE_off && tRNS_off, "PLTE offset %d, tRNS offset %d\n", PLTE_off, tRNS_off);
5275 if (!PLTE_off || !tRNS_off) return;
5276
5277 /* In order to test the image data with and without PLTE and tRNS
5278 * chunks, we mask the chunk name with private one (tEST).
5279 */
5280
5281 for (i = 0; i < ARRAY_SIZE(td); i++)
5282 {
5283 for (j = 0; j < 3; j++)
5284 {
5285 memcpy(buf, png_1x1_data, sizeof(png_1x1_data));
5286 buf[24] = td[i].bit_depth;
5287 buf[25] = td[i].color_type;
5288 if (j >=1) memcpy(buf + tRNS_off, "tEST", 4);
5289 if (j >=2) memcpy(buf + PLTE_off, "tEST", 4);
5290
5291 valid = (td[i].t[j].format != 0) || (td[i].t[j].flags != 0);
5292 image = load_image(buf, sizeof(buf), valid, td[i].t[j].todo_load);
5293 todo_wine_if(td[i].t[j].todo_load)
5294 if (valid)
5295 ok(image != NULL, "%d %d: failed to load image data\n", i, j);
5296 else
5297 {
5298 ok(image == NULL, "%d %d: succeed to load image data\n", i, j);
5299 if (image) GdipDisposeImage(image);
5300 image = NULL;
5301 }
5302 if (!image) continue;
5303
5304 status = GdipGetImageType(image, &type);
5305 ok(status == Ok, "%d %d: GdipGetImageType error %d\n", i, j, status);
5306 ok(type == ImageTypeBitmap, "%d %d: wrong image type %d\n", i, j, type);
5307
5308 status = GdipGetImagePixelFormat(image, &format);
5309 expect(Ok, status);
5310 todo_wine_if(td[i].t[j].todo)
5311 ok(format == td[i].t[j].format,
5312 "%d %d: expected %#x, got %#x\n", i, j, td[i].t[j].format, format);
5313
5314 status = GdipGetImageFlags(image, &flags);
5315 expect(Ok, status);
5316 ok((flags & color_space_mask) == td[i].t[j].flags,
5317 "%d %d: expected %#x, got %#x\n", i, j, td[i].t[j].flags, flags);
5318 GdipDisposeImage(image);
5319 }
5320 }
5321 }
5322 #undef PNG_COLOR_TYPE_GRAY
5323 #undef PNG_COLOR_TYPE_RGB
5324 #undef PNG_COLOR_TYPE_PALETTE
5325 #undef PNG_COLOR_TYPE_GRAY_ALPHA
5326 #undef PNG_COLOR_TYPE_RGB_ALPHA
5327
5328 static void test_GdipLoadImageFromStream(void)
5329 {
5330 IStream *stream;
5331 GpStatus status;
5332 GpImage *image;
5333 HGLOBAL hglob;
5334 BYTE *data;
5335 HRESULT hr;
5336
5337 status = GdipLoadImageFromStream(NULL, NULL);
5338 ok(status == InvalidParameter, "Unexpected return value %d.\n", status);
5339
5340 image = (void *)0xdeadbeef;
5341 status = GdipLoadImageFromStream(NULL, &image);
5342 ok(status == InvalidParameter, "Unexpected return value %d.\n", status);
5343 ok(image == (void *)0xdeadbeef, "Unexpected image pointer.\n");
5344
5345 hglob = GlobalAlloc(0, sizeof(pngimage));
5346 data = GlobalLock (hglob);
5347 memcpy(data, pngimage, sizeof(pngimage));
5348 GlobalUnlock(hglob);
5349
5350 hr = CreateStreamOnHGlobal(hglob, TRUE, &stream);
5351 ok(hr == S_OK, "Failed to create a stream.\n");
5352
5353 status = GdipLoadImageFromStream(stream, NULL);
5354 ok(status == InvalidParameter, "Unexpected return value %d.\n", status);
5355
5356 IStream_Release(stream);
5357 }
5358
5359 static BYTE *init_bitmap(UINT *width, UINT *height, UINT *stride)
5360 {
5361 BYTE *src;
5362 UINT i, j, scale;
5363
5364 *width = 256;
5365 *height = 256;
5366 *stride = (*width * 3 + 3) & ~3;
5367 trace("width %d, height %d, stride %d\n", *width, *height, *stride);
5368
5369 src = HeapAlloc(GetProcessHeap(), 0, *stride * *height);
5370
5371 scale = 256 / *width;
5372 if (!scale) scale = 1;
5373
5374 for (i = 0; i < *height; i++)
5375 {
5376 for (j = 0; j < *width; j++)
5377 {
5378 src[i * *stride + j*3 + 0] = scale * i;
5379 src[i * *stride + j*3 + 1] = scale * (255 - (i+j)/2);
5380 src[i * *stride + j*3 + 2] = scale * j;
5381 }
5382 }
5383
5384 return src;
5385 }
5386
5387 static void test_GdipInitializePalette(void)
5388 {
5389 GpStatus status;
5390 BYTE *data;
5391 GpBitmap *bitmap;
5392 ColorPalette *palette;
5393 UINT width, height, stride;
5394
5395 pGdipInitializePalette = (void *)GetProcAddress(GetModuleHandleA("gdiplus.dll"), "GdipInitializePalette");
5396 if (!pGdipInitializePalette)
5397 {
5398 win_skip("GdipInitializePalette is not supported on this platform\n");
5399 return;
5400 }
5401
5402 data = init_bitmap(&width, &height, &stride);
5403
5404 status = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat24bppRGB, data, &bitmap);
5405 expect(Ok, status);
5406
5407 palette = GdipAlloc(sizeof(*palette) + sizeof(ARGB) * 255);
5408
5409 palette->Flags = 0;
5410 palette->Count = 15;
5411 status = pGdipInitializePalette(palette, PaletteTypeOptimal, 16, FALSE, bitmap);
5412 expect(GenericError, status);
5413
5414 palette->Flags = 0;
5415 palette->Count = 256;
5416 status = pGdipInitializePalette(palette, PaletteTypeOptimal, 16, FALSE, NULL);
5417 expect(InvalidParameter, status);
5418
5419 memset(palette->Entries, 0x11, sizeof(ARGB) * 256);
5420 palette->Flags = 0;
5421 palette->Count = 256;
5422 status = pGdipInitializePalette(palette, PaletteTypeCustom, 16, FALSE, NULL);
5423 expect(Ok, status);
5424 expect(0, palette->Flags);
5425 expect(256, palette->Count);
5426 expect(0x11111111, palette->Entries[0]);
5427 expect(0x11111111, palette->Entries[128]);
5428 expect(0x11111111, palette->Entries[255]);
5429
5430 memset(palette->Entries, 0x11, sizeof(ARGB) * 256);
5431 palette->Flags = 0;
5432 palette->Count = 256;
5433 status = pGdipInitializePalette(palette, PaletteTypeFixedBW, 0, FALSE, bitmap);
5434 expect(Ok, status);
5435 todo_wine
5436 expect(0x200, palette->Flags);
5437 expect(2, palette->Count);
5438 expect(0xff000000, palette->Entries[0]);
5439 expect(0xffffffff, palette->Entries[1]);
5440
5441 memset(palette->Entries, 0x11, sizeof(ARGB) * 256);
5442 palette->Flags = 0;
5443 palette->Count = 256;
5444 status = pGdipInitializePalette(palette, PaletteTypeFixedHalftone8, 1, FALSE, NULL);
5445 expect(Ok, status);
5446 todo_wine
5447 expect(0x300, palette->Flags);
5448 expect(16, palette->Count);
5449 expect(0xff000000, palette->Entries[0]);
5450 expect(0xffc0c0c0, palette->Entries[8]);
5451 expect(0xff008080, palette->Entries[15]);
5452
5453 memset(palette->Entries, 0x11, sizeof(ARGB) * 256);
5454 palette->Flags = 0;
5455 palette->Count = 256;
5456 status = pGdipInitializePalette(palette, PaletteTypeFixedHalftone8, 1, FALSE, bitmap);
5457 expect(Ok, status);
5458 todo_wine
5459 expect(0x300, palette->Flags);
5460 expect(16, palette->Count);
5461 expect(0xff000000, palette->Entries[0]);
5462 expect(0xffc0c0c0, palette->Entries[8]);
5463 expect(0xff008080, palette->Entries[15]);
5464
5465 memset(palette->Entries, 0x11, sizeof(ARGB) * 256);
5466 palette->Flags = 0;
5467 palette->Count = 256;
5468 status = pGdipInitializePalette(palette, PaletteTypeFixedHalftone252, 1, FALSE, bitmap);
5469 expect(Ok, status);
5470 todo_wine
5471 expect(0x800, palette->Flags);
5472 expect(252, palette->Count);
5473 expect(0xff000000, palette->Entries[0]);
5474 expect(0xff990066, palette->Entries[128]);
5475 expect(0xffffffff, palette->Entries[251]);
5476
5477 palette->Flags = 0;
5478 palette->Count = 256;
5479 status = pGdipInitializePalette(palette, PaletteTypeOptimal, 1, FALSE, bitmap);
5480 expect(InvalidParameter, status);
5481
5482 palette->Flags = 0;
5483 palette->Count = 256;
5484 status = pGdipInitializePalette(palette, PaletteTypeOptimal, 2, FALSE, bitmap);
5485 expect(Ok, status);
5486 expect(0, palette->Flags);
5487 expect(2, palette->Count);
5488
5489 palette->Flags = 0;
5490 palette->Count = 256;
5491 status = pGdipInitializePalette(palette, PaletteTypeOptimal, 16, FALSE, bitmap);
5492 expect(Ok, status);
5493 expect(0, palette->Flags);
5494 expect(16, palette->Count);
5495
5496 /* passing invalid enumeration palette type crashes under most Windows versions */
5497
5498 GdipFree(palette);
5499 GdipDisposeImage((GpImage *)bitmap);
5500 }
5501
5502 #include "pshpack2.h"
5503 static const struct tiff_1x1_data
5504 {
5505 USHORT byte_order;
5506 USHORT version;
5507 ULONG dir_offset;
5508 USHORT number_of_entries;
5509 struct IFD_entry entry[12];
5510 ULONG next_IFD;
5511 struct IFD_rational res;
5512 short palette_data[3][256];
5513 short bps_data[4];
5514 BYTE pixel_data[32];
5515 } tiff_1x1_data =
5516 {
5517 #ifdef WORDS_BIGENDIAN
5518 'M' | 'M' << 8,
5519 #else
5520 'I' | 'I' << 8,
5521 #endif
5522 42,
5523 FIELD_OFFSET(struct tiff_1x1_data, number_of_entries),
5524 12,
5525 {
5526 { 0xff, IFD_SHORT, 1, 0 }, /* SUBFILETYPE */
5527 { 0x100, IFD_LONG, 1, 1 }, /* IMAGEWIDTH */
5528 { 0x101, IFD_LONG, 1, 1 }, /* IMAGELENGTH */
5529 { 0x102, IFD_SHORT, 3, FIELD_OFFSET(struct tiff_1x1_data, bps_data) }, /* BITSPERSAMPLE */
5530 { 0x103, IFD_SHORT, 1, 1 }, /* COMPRESSION: XP doesn't accept IFD_LONG here */
5531 { 0x106, IFD_SHORT, 1, 2 }, /* PHOTOMETRIC */
5532 { 0x111, IFD_LONG, 1, FIELD_OFFSET(struct tiff_1x1_data, pixel_data) }, /* STRIPOFFSETS */
5533 { 0x115, IFD_SHORT, 1, 3 }, /* SAMPLESPERPIXEL */
5534 { 0x11a, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1x1_data, res) },
5535 { 0x11b, IFD_RATIONAL, 1, FIELD_OFFSET(struct tiff_1x1_data, res) },
5536 { 0x128, IFD_SHORT, 1, 2 }, /* RESOLUTIONUNIT */
5537 { 0x140, IFD_SHORT, 256*3, FIELD_OFFSET(struct tiff_1x1_data, palette_data) } /* COLORMAP */
5538 },
5539 0,
5540 { 96, 1 },
5541 { { 0 } },
5542 { 8,8,8,0 },
5543 { 1,0,2,3,4,5,6,7,8,9,0,1,2,3,4,5 }
5544 };
5545 #include "poppack.h"
5546
5547 static void test_tiff_color_formats(void)
5548 {
5549 static const struct
5550 {
5551 int photometric; /* PhotometricInterpretation */
5552 int samples; /* SamplesPerPixel */
5553 int bps; /* BitsPerSample */
5554 PixelFormat format;
5555 } td[] =
5556 {
5557 /* 2 - RGB */
5558 { 2, 3, 1, PixelFormat24bppRGB },
5559 { 2, 3, 4, PixelFormat24bppRGB },
5560 { 2, 3, 8, PixelFormat24bppRGB },
5561 { 2, 3, 16, PixelFormat48bppRGB },
5562 { 2, 3, 24, 0 },
5563 #if 0 /* FIXME */
5564 { 2, 3, 32, 0 },
5565 #endif
5566 { 2, 4, 1, PixelFormat32bppARGB },
5567 { 2, 4, 4, PixelFormat32bppARGB },
5568 { 2, 4, 8, PixelFormat32bppARGB },
5569 { 2, 4, 16, PixelFormat48bppRGB },
5570 { 2, 4, 24, 0 },
5571 { 2, 4, 32, 0 },
5572 /* 1 - BlackIsZero (Bilevel) */
5573 { 1, 1, 1, PixelFormat1bppIndexed },
5574 #if 0 /* FIXME: PNG vs TIFF mismatch */
5575 { 1, 1, 4, PixelFormat8bppIndexed },
5576 #endif
5577 { 1, 1, 8, PixelFormat8bppIndexed },
5578 { 1, 1, 16, PixelFormat32bppARGB },
5579 { 1, 1, 24, 0 },
5580 { 1, 1, 32, PixelFormat32bppARGB },
5581 /* 3 - Palette Color */
5582 { 3, 1, 1, PixelFormat1bppIndexed },
5583 { 3, 1, 4, PixelFormat4bppIndexed },
5584 { 3, 1, 8, PixelFormat8bppIndexed },
5585 #if 0 /* FIXME: for some reason libtiff replaces photometric 3 by 1 for bps > 8 */
5586 { 3, 1, 16, 0 },
5587 { 3, 1, 24, 0 },
5588 { 3, 1, 32, 0 },
5589 #endif
5590 /* 5 - Separated */
5591 { 5, 4, 1, 0 },
5592 { 5, 4, 4, 0 },
5593 { 5, 4, 8, PixelFormat32bppCMYK },
5594 { 5, 4, 16, PixelFormat48bppRGB },
5595 { 5, 4, 24, 0 },
5596 { 5, 4, 32, 0 },
5597 };
5598 BYTE buf[sizeof(tiff_1x1_data)];
5599 GpStatus status;
5600 GpImage *image;
5601 UINT count, i;
5602 struct IFD_entry *tag, *tag_photo = NULL, *tag_bps = NULL, *tag_samples = NULL, *tag_colormap = NULL;
5603 short *bps;
5604 ImageType type;
5605 PixelFormat format;
5606
5607 memcpy(buf, &tiff_1x1_data, sizeof(tiff_1x1_data));
5608
5609 count = *(short *)(buf + tiff_1x1_data.dir_offset);
5610 tag = (struct IFD_entry *)(buf + tiff_1x1_data.dir_offset + sizeof(short));
5611
5612 /* verify the TIFF structure */
5613 for (i = 0; i < count; i++)
5614 {
5615 if (tag[i].id == 0x102) /* BitsPerSample */
5616 tag_bps = &tag[i];
5617 else if (tag[i].id == 0x106) /* PhotometricInterpretation */
5618 tag_photo = &tag[i];
5619 else if (tag[i].id == 0x115) /* SamplesPerPixel */
5620 tag_samples = &tag[i];
5621 else if (tag[i].id == 0x140) /* ColorMap */
5622 tag_colormap = &tag[i];
5623 }
5624
5625 ok(tag_bps && tag_photo && tag_samples && tag_colormap, "tag 0x102,0x106,0x115 or 0x140 is missing\n");
5626 if (!tag_bps || !tag_photo || !tag_samples || !tag_colormap) return;
5627
5628 ok(tag_bps->type == IFD_SHORT, "tag 0x102 should have type IFD_SHORT\n");
5629 bps = (short *)(buf + tag_bps->value);
5630 ok(bps[0] == 8 && bps[1] == 8 && bps[2] == 8 && bps[3] == 0,
5631 "expected bps 8,8,8,0 got %d,%d,%d,%d\n", bps[0], bps[1], bps[2], bps[3]);
5632
5633 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
5634 {
5635 tag_colormap->count = (1 << td[i].bps) * 3;
5636 tag_photo->value = td[i].photometric;
5637 tag_bps->count = td[i].samples;
5638 tag_samples->value = td[i].samples;
5639
5640 if (td[i].samples == 1)
5641 tag_bps->value = td[i].bps;
5642 else if (td[i].samples == 2)
5643 tag_bps->value = MAKELONG(td[i].bps, td[i].bps);
5644 else if (td[i].samples == 3)
5645 {
5646 tag_bps->value = (BYTE *)bps - buf;
5647 bps[0] = bps[1] = bps[2] = td[i].bps;
5648 }
5649 else if (td[i].samples == 4)
5650 {
5651 tag_bps->value = (BYTE *)bps - buf;
5652 bps[0] = bps[1] = bps[2] = bps[3] = td[i].bps;
5653 }
5654 else
5655 {
5656 ok(0, "%u: unsupported samples count %d\n", i, td[i].samples);
5657 continue;
5658 }
5659
5660 image = load_image(buf, sizeof(buf), TRUE, FALSE);
5661 if (!td[i].format)
5662 #ifdef __REACTOS__
5663 ok(!image || (((GetVersion() & 0xFF) < 6) &&
5664 (i == 19 || i == 20)),
5665 #else
5666 ok(!image,
5667 #endif
5668 "%u: (%d,%d,%d) TIFF image loading should have failed\n", i, td[i].photometric, td[i].samples, td[i].bps);
5669 else
5670 ok(image != NULL || broken(!image) /* XP */, "%u: failed to load TIFF image data (%d,%d,%d)\n",
5671 i, td[i].photometric, td[i].samples, td[i].bps);
5672 if (!image) continue;
5673
5674 status = GdipGetImageType(image, &type);
5675 ok(status == Ok, "%u: GdipGetImageType error %d\n", i, status);
5676 ok(type == ImageTypeBitmap, "%u: wrong image type %d\n", i, type);
5677
5678 status = GdipGetImagePixelFormat(image, &format);
5679 expect(Ok, status);
5680 #ifdef __REACTOS__
5681 ok(format == td[i].format || (((GetVersion() & 0xFF) < 6) &&
5682 ((i == 0 && format == 0) ||
5683 (i == 1 && format == 0) ||
5684 (i == 5 && format == 0) ||
5685 (i == 6 && format == 0) ||
5686 (i == 13 && format == 0) ||
5687 (i == 19 && format == PixelFormat32bppARGB) ||
5688 (i == 20 && format == PixelFormat32bppARGB) ||
5689 (i == 21 && format == PixelFormat32bppARGB) ||
5690 (i == 22 && format == PixelFormat32bppARGB))),
5691 #else
5692 ok(format == td[i].format,
5693 #endif
5694 "%u: expected %#x, got %#x\n", i, td[i].format, format);
5695
5696 GdipDisposeImage(image);
5697 }
5698 }
5699
5700 START_TEST(image)
5701 {
5702 HMODULE mod = GetModuleHandleA("gdiplus.dll");
5703 struct GdiplusStartupInput gdiplusStartupInput;
5704 ULONG_PTR gdiplusToken;
5705 HMODULE hmsvcrt;
5706 int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
5707
5708 /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
5709 hmsvcrt = LoadLibraryA("msvcrt");
5710 _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
5711 if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
5712
5713 gdiplusStartupInput.GdiplusVersion = 1;
5714 gdiplusStartupInput.DebugEventCallback = NULL;
5715 gdiplusStartupInput.SuppressBackgroundThread = 0;
5716 gdiplusStartupInput.SuppressExternalCodecs = 0;
5717
5718 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
5719
5720 pGdipBitmapGetHistogramSize = (void*)GetProcAddress(mod, "GdipBitmapGetHistogramSize");
5721 pGdipBitmapGetHistogram = (void*)GetProcAddress(mod, "GdipBitmapGetHistogram");
5722 pGdipImageSetAbort = (void*)GetProcAddress(mod, "GdipImageSetAbort");
5723
5724 test_tiff_color_formats();
5725 test_GdipInitializePalette();
5726 test_png_color_formats();
5727 test_supported_encoders();
5728 test_CloneBitmapArea();
5729 test_ARGB_conversion();
5730 test_DrawImage_scale();
5731 test_image_format();
5732 test_DrawImage();
5733 test_DrawImage_SourceCopy();
5734 test_GdipDrawImagePointRect();
5735 test_bitmapbits();
5736 test_tiff_palette();
5737 test_GdipGetAllPropertyItems();
5738 test_tiff_properties();
5739 test_gif_properties();
5740 test_image_properties();
5741 test_Scan0();
5742 test_FromGdiDib();
5743 test_GetImageDimension();
5744 test_GdipImageGetFrameDimensionsCount();
5745 test_LoadingImages();
5746 test_SavingImages();
5747 test_encoders();
5748 test_LockBits();
5749 test_LockBits_UserBuf();
5750 test_GdipCreateBitmapFromHBITMAP();
5751 test_GdipGetImageFlags();
5752 test_GdipCloneImage();
5753 test_testcontrol();
5754 test_fromhicon();
5755 test_getrawformat();
5756 test_loadwmf();
5757 test_createfromwmf();
5758 test_createfromwmf_noplaceable();
5759 test_resolution();
5760 test_createhbitmap();
5761 test_getthumbnail();
5762 test_getsetpixel();
5763 test_palette();
5764 test_colormatrix();
5765 test_gamma();
5766 test_multiframegif();
5767 test_rotateflip();
5768 test_remaptable();
5769 test_colorkey();
5770 test_dispose();
5771 test_createeffect();
5772 test_getadjustedpalette();
5773 test_histogram();
5774 test_imageabort();
5775 test_GdipLoadImageFromStream();
5776
5777 GdiplusShutdown(gdiplusToken);
5778 }
A free Windows-compatible Operating System