2 * Unit test suite for images
4 * Copyright (C) 2007 Google (Evan Stade)
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/test.h"
32 #define expect(expected, got) ok((got) == (expected), "Expected %d, got %d\n", (UINT)(expected), (UINT)(got))
33 #define expectf(expected, got) ok(fabs((expected) - (got)) < 0.0001, "Expected %f, got %f\n", (expected), (got))
35 static BOOL
color_match(ARGB c1
, ARGB c2
, BYTE max_diff
)
37 if (abs((c1
& 0xff) - (c2
& 0xff)) > max_diff
) return FALSE
;
39 if (abs((c1
& 0xff) - (c2
& 0xff)) > max_diff
) return FALSE
;
41 if (abs((c1
& 0xff) - (c2
& 0xff)) > max_diff
) return FALSE
;
43 if (abs((c1
& 0xff) - (c2
& 0xff)) > max_diff
) return FALSE
;
47 static void expect_guid(REFGUID expected
, REFGUID got
, int line
, BOOL todo
)
53 StringFromGUID2(got
, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]));
54 WideCharToMultiByte(CP_ACP
, 0, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]), buffer
, sizeof(buffer
), NULL
, NULL
);
55 StringFromGUID2(expected
, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]));
56 WideCharToMultiByte(CP_ACP
, 0, bufferW
, sizeof(bufferW
)/sizeof(bufferW
[0]), buffer2
, sizeof(buffer2
), NULL
, NULL
);
58 todo_wine
ok_(__FILE__
, line
)(IsEqualGUID(expected
, got
), "Expected %s, got %s\n", buffer2
, buffer
);
60 ok_(__FILE__
, line
)(IsEqualGUID(expected
, got
), "Expected %s, got %s\n", buffer2
, buffer
);
63 static void expect_rawformat(REFGUID expected
, GpImage
*img
, int line
, BOOL todo
)
68 stat
= GdipGetImageRawFormat(img
, &raw
);
69 ok_(__FILE__
, line
)(stat
== Ok
, "GdipGetImageRawFormat failed with %d\n", stat
);
70 if(stat
!= Ok
) return;
71 expect_guid(expected
, &raw
, line
, todo
);
74 static void test_bufferrawformat(void* buff
, int size
, REFGUID expected
, int line
, BOOL todo
)
83 hglob
= GlobalAlloc (0, size
);
84 data
= GlobalLock (hglob
);
85 memcpy(data
, buff
, size
);
86 GlobalUnlock(hglob
); data
= NULL
;
88 hres
= CreateStreamOnHGlobal(hglob
, TRUE
, &stream
);
89 ok_(__FILE__
, line
)(hres
== S_OK
, "Failed to create a stream\n");
90 if(hres
!= S_OK
) return;
92 stat
= GdipLoadImageFromStream(stream
, &img
);
93 ok_(__FILE__
, line
)(stat
== Ok
, "Failed to create a Bitmap\n");
95 IStream_Release(stream
);
99 expect_rawformat(expected
, img
, line
, todo
);
101 GdipDisposeImage(img
);
102 IStream_Release(stream
);
105 static void test_Scan0(void)
112 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB
, NULL
, &bm
);
114 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
116 GdipDisposeImage((GpImage
*)bm
);
118 bm
= (GpBitmap
*)0xdeadbeef;
119 stat
= GdipCreateBitmapFromScan0(10, -10, 10, PixelFormat24bppRGB
, NULL
, &bm
);
120 expect(InvalidParameter
, stat
);
121 ok( !bm
, "expected null bitmap\n" );
123 bm
= (GpBitmap
*)0xdeadbeef;
124 stat
= GdipCreateBitmapFromScan0(-10, 10, 10, PixelFormat24bppRGB
, NULL
, &bm
);
125 expect(InvalidParameter
, stat
);
126 ok( !bm
, "expected null bitmap\n" );
128 bm
= (GpBitmap
*)0xdeadbeef;
129 stat
= GdipCreateBitmapFromScan0(10, 0, 10, PixelFormat24bppRGB
, NULL
, &bm
);
130 expect(InvalidParameter
, stat
);
131 ok( !bm
, "expected null bitmap\n" );
134 stat
= GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB
, buff
, &bm
);
136 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
138 GdipDisposeImage((GpImage
*)bm
);
140 bm
= (GpBitmap
*) 0xdeadbeef;
141 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB
, buff
, &bm
);
142 expect(InvalidParameter
, stat
);
143 ok( !bm
, "expected null bitmap\n" );
145 bm
= (GpBitmap
*)0xdeadbeef;
146 stat
= GdipCreateBitmapFromScan0(10, 10, 0, PixelFormat24bppRGB
, buff
, &bm
);
147 expect(InvalidParameter
, stat
);
148 ok( bm
== (GpBitmap
*)0xdeadbeef, "expected deadbeef bitmap\n" );
151 stat
= GdipCreateBitmapFromScan0(10, 10, -8, PixelFormat24bppRGB
, buff
, &bm
);
153 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
155 GdipDisposeImage((GpImage
*)bm
);
157 bm
= (GpBitmap
*)0xdeadbeef;
158 stat
= GdipCreateBitmapFromScan0(10, 10, -10, PixelFormat24bppRGB
, buff
, &bm
);
159 expect(InvalidParameter
, stat
);
160 ok( !bm
, "expected null bitmap\n" );
163 static void test_FromGdiDib(void)
168 BYTE rbmi
[sizeof(BITMAPINFOHEADER
)+256*sizeof(RGBQUAD
)];
169 BITMAPINFO
*bmi
= (BITMAPINFO
*)rbmi
;
174 memset(rbmi
, 0, sizeof(rbmi
));
176 bmi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
177 bmi
->bmiHeader
.biWidth
= 10;
178 bmi
->bmiHeader
.biHeight
= 10;
179 bmi
->bmiHeader
.biPlanes
= 1;
180 bmi
->bmiHeader
.biBitCount
= 32;
181 bmi
->bmiHeader
.biCompression
= BI_RGB
;
183 stat
= GdipCreateBitmapFromGdiDib(NULL
, buff
, &bm
);
184 expect(InvalidParameter
, stat
);
186 stat
= GdipCreateBitmapFromGdiDib(bmi
, NULL
, &bm
);
187 expect(InvalidParameter
, stat
);
189 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, NULL
);
190 expect(InvalidParameter
, stat
);
192 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
194 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
197 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
199 expect(PixelFormat32bppRGB
, format
);
201 GdipDisposeImage((GpImage
*)bm
);
204 bmi
->bmiHeader
.biBitCount
= 24;
205 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
207 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
210 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
212 expect(PixelFormat24bppRGB
, format
);
214 GdipDisposeImage((GpImage
*)bm
);
217 bmi
->bmiHeader
.biBitCount
= 16;
218 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
220 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
223 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
225 expect(PixelFormat16bppRGB555
, format
);
227 GdipDisposeImage((GpImage
*)bm
);
230 bmi
->bmiHeader
.biBitCount
= 8;
231 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
233 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
236 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
238 expect(PixelFormat8bppIndexed
, format
);
240 GdipDisposeImage((GpImage
*)bm
);
243 bmi
->bmiHeader
.biBitCount
= 4;
244 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
246 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
249 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
251 expect(PixelFormat4bppIndexed
, format
);
253 GdipDisposeImage((GpImage
*)bm
);
256 bmi
->bmiHeader
.biBitCount
= 1;
257 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
259 ok(NULL
!= bm
, "Expected bitmap to be initialized\n");
262 stat
= GdipGetImagePixelFormat((GpImage
*)bm
, &format
);
264 expect(PixelFormat1bppIndexed
, format
);
266 GdipDisposeImage((GpImage
*)bm
);
269 bmi
->bmiHeader
.biBitCount
= 0;
270 stat
= GdipCreateBitmapFromGdiDib(bmi
, buff
, &bm
);
271 expect(InvalidParameter
, stat
);
274 static void test_GetImageDimension(void)
278 const REAL WIDTH
= 10.0, HEIGHT
= 20.0;
281 bm
= (GpBitmap
*)0xdeadbeef;
282 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
,NULL
, &bm
);
284 ok((GpBitmap
*)0xdeadbeef != bm
, "Expected bitmap to not be 0xdeadbeef\n");
285 ok(NULL
!= bm
, "Expected bitmap to not be NULL\n");
287 stat
= GdipGetImageDimension(NULL
,&w
,&h
);
288 expect(InvalidParameter
, stat
);
290 stat
= GdipGetImageDimension((GpImage
*)bm
,NULL
,&h
);
291 expect(InvalidParameter
, stat
);
293 stat
= GdipGetImageDimension((GpImage
*)bm
,&w
,NULL
);
294 expect(InvalidParameter
, stat
);
298 stat
= GdipGetImageDimension((GpImage
*)bm
,&w
,&h
);
302 GdipDisposeImage((GpImage
*)bm
);
305 static void test_GdipImageGetFrameDimensionsCount(void)
309 const REAL WIDTH
= 10.0, HEIGHT
= 20.0;
311 GUID dimension
= {0};
315 bm
= (GpBitmap
*)0xdeadbeef;
316 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
,NULL
, &bm
);
318 ok((GpBitmap
*)0xdeadbeef != bm
, "Expected bitmap to not be 0xdeadbeef\n");
319 ok(NULL
!= bm
, "Expected bitmap to not be NULL\n");
321 stat
= GdipImageGetFrameDimensionsCount(NULL
,&w
);
322 expect(InvalidParameter
, stat
);
324 stat
= GdipImageGetFrameDimensionsCount((GpImage
*)bm
,NULL
);
325 expect(InvalidParameter
, stat
);
328 stat
= GdipImageGetFrameDimensionsCount((GpImage
*)bm
,&w
);
332 stat
= GdipImageGetFrameDimensionsList((GpImage
*)bm
, &dimension
, 1);
334 expect_guid(&FrameDimensionPage
, &dimension
, __LINE__
, FALSE
);
336 stat
= GdipImageGetFrameDimensionsList((GpImage
*)bm
, &dimension
, 2);
337 expect(InvalidParameter
, stat
);
339 stat
= GdipImageGetFrameDimensionsList((GpImage
*)bm
, &dimension
, 0);
340 expect(InvalidParameter
, stat
);
342 stat
= GdipImageGetFrameCount(NULL
, &dimension
, &count
);
343 expect(InvalidParameter
, stat
);
345 /* WinXP crashes on this test */
348 stat
= GdipImageGetFrameCount((GpImage
*)bm
, &dimension
, NULL
);
349 expect(InvalidParameter
, stat
);
352 stat
= GdipImageGetFrameCount((GpImage
*)bm
, NULL
, &count
);
356 stat
= GdipImageGetFrameCount((GpImage
*)bm
, &dimension
, &count
);
360 GdipBitmapSetPixel(bm
, 0, 0, 0xffffffff);
362 stat
= GdipImageSelectActiveFrame((GpImage
*)bm
, &dimension
, 0);
365 /* SelectActiveFrame has no effect on image data of memory bitmaps */
367 GdipBitmapGetPixel(bm
, 0, 0, &color
);
368 expect(0xffffffff, color
);
370 GdipDisposeImage((GpImage
*)bm
);
373 static void test_LoadingImages(void)
377 stat
= GdipCreateBitmapFromFile(0, 0);
378 expect(InvalidParameter
, stat
);
380 stat
= GdipCreateBitmapFromFile(0, (GpBitmap
**)0xdeadbeef);
381 expect(InvalidParameter
, stat
);
383 stat
= GdipLoadImageFromFile(0, 0);
384 expect(InvalidParameter
, stat
);
386 stat
= GdipLoadImageFromFile(0, (GpImage
**)0xdeadbeef);
387 expect(InvalidParameter
, stat
);
389 stat
= GdipLoadImageFromFileICM(0, 0);
390 expect(InvalidParameter
, stat
);
392 stat
= GdipLoadImageFromFileICM(0, (GpImage
**)0xdeadbeef);
393 expect(InvalidParameter
, stat
);
396 static void test_SavingImages(void)
402 const REAL WIDTH
= 10.0, HEIGHT
= 20.0;
404 ImageCodecInfo
*codecs
;
405 static const CHAR filenameA
[] = "a.bmp";
406 static const WCHAR filename
[] = { 'a','.','b','m','p',0 };
410 stat
= GdipSaveImageToFile(0, 0, 0, 0);
411 expect(InvalidParameter
, stat
);
414 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
420 stat
= GdipSaveImageToFile((GpImage
*)bm
, 0, 0, 0);
421 expect(InvalidParameter
, stat
);
423 stat
= GdipSaveImageToFile((GpImage
*)bm
, filename
, 0, 0);
424 expect(InvalidParameter
, stat
);
426 /* encoder tests should succeed -- already tested */
427 stat
= GdipGetImageEncodersSize(&n
, &s
);
428 if (stat
!= Ok
|| n
== 0) goto cleanup
;
430 codecs
= GdipAlloc(s
);
431 if (!codecs
) goto cleanup
;
433 stat
= GdipGetImageEncoders(n
, s
, codecs
);
434 if (stat
!= Ok
) goto cleanup
;
436 stat
= GdipSaveImageToFile((GpImage
*)bm
, filename
, &codecs
[0].Clsid
, 0);
439 GdipDisposeImage((GpImage
*)bm
);
442 /* re-load and check image stats */
443 stat
= GdipLoadImageFromFile(filename
, (GpImage
**)&bm
);
445 if (stat
!= Ok
) goto cleanup
;
447 stat
= GdipGetImageDimension((GpImage
*)bm
, &w
, &h
);
448 if (stat
!= Ok
) goto cleanup
;
456 GdipDisposeImage((GpImage
*)bm
);
457 ok(DeleteFileA(filenameA
), "Delete failed.\n");
460 static void test_encoders(void)
465 ImageCodecInfo
*codecs
;
469 static const CHAR bmp_format
[] = "BMP";
471 stat
= GdipGetImageEncodersSize(&n
, &s
);
474 codecs
= GdipAlloc(s
);
478 stat
= GdipGetImageEncoders(n
, s
, NULL
);
479 expect(GenericError
, stat
);
481 stat
= GdipGetImageEncoders(0, s
, codecs
);
482 expect(GenericError
, stat
);
484 stat
= GdipGetImageEncoders(n
, s
-1, codecs
);
485 expect(GenericError
, stat
);
487 stat
= GdipGetImageEncoders(n
, s
+1, codecs
);
488 expect(GenericError
, stat
);
490 stat
= GdipGetImageEncoders(n
, s
, codecs
);
494 for (i
= 0; i
< n
; i
++)
498 WideCharToMultiByte(CP_ACP
, 0, codecs
[i
].FormatDescription
, -1,
501 if (CompareStringA(LOCALE_SYSTEM_DEFAULT
, 0,
503 bmp_format
, -1) == CSTR_EQUAL
) {
509 ok(FALSE
, "No BMP codec found.\n");
514 static void test_LockBits(void)
520 const INT WIDTH
= 10, HEIGHT
= 20;
525 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
533 stat
= GdipBitmapSetPixel(bm
, 2, 3, 0xffc30000);
536 stat
= GdipBitmapSetPixel(bm
, 2, 8, 0xff480000);
540 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
544 expect(0xc3, ((BYTE
*)bd
.Scan0
)[2]);
545 expect(0x48, ((BYTE
*)bd
.Scan0
)[2 + bd
.Stride
* 5]);
547 ((char*)bd
.Scan0
)[2] = 0xff;
549 stat
= GdipBitmapUnlockBits(bm
, &bd
);
553 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
555 expect(0xffff0000, color
);
557 stat
= GdipBitmapSetPixel(bm
, 2, 3, 0xffc30000);
560 /* read-only, with NULL rect -> whole bitmap lock */
561 stat
= GdipBitmapLockBits(bm
, NULL
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
563 expect(bd
.Width
, WIDTH
);
564 expect(bd
.Height
, HEIGHT
);
567 ((char*)bd
.Scan0
)[2 + 2*3 + 3*bd
.Stride
] = 0xff;
569 stat
= GdipBitmapUnlockBits(bm
, &bd
);
573 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
575 expect(0xffff0000, color
);
577 /* read-only, consecutive */
578 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
582 stat
= GdipBitmapUnlockBits(bm
, &bd
);
586 stat
= GdipDisposeImage((GpImage
*)bm
);
588 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
592 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
594 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
595 expect(WrongState
, stat
);
597 stat
= GdipBitmapUnlockBits(bm
, &bd
);
600 stat
= GdipDisposeImage((GpImage
*)bm
);
602 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
605 stat
= GdipBitmapSetPixel(bm
, 2, 3, 0xffff0000);
608 stat
= GdipBitmapSetPixel(bm
, 2, 8, 0xffc30000);
611 /* write, no conversion */
612 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
, PixelFormat24bppRGB
, &bd
);
616 /* all bits are readable, inside the rect or not */
617 expect(0xff, ((BYTE
*)bd
.Scan0
)[2]);
618 expect(0xc3, ((BYTE
*)bd
.Scan0
)[2 + bd
.Stride
* 5]);
620 stat
= GdipBitmapUnlockBits(bm
, &bd
);
624 /* read, conversion */
625 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat32bppARGB
, &bd
);
629 expect(0xff, ((BYTE
*)bd
.Scan0
)[2]);
631 /* Areas outside the rectangle appear to be uninitialized */
632 ok(0xc3 != ((BYTE
*)bd
.Scan0
)[2 + bd
.Stride
* 5], "original image bits are readable\n");
634 ((BYTE
*)bd
.Scan0
)[2] = 0xc3;
636 stat
= GdipBitmapUnlockBits(bm
, &bd
);
640 /* writes do not work in read mode if there was a conversion */
641 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
643 expect(0xffff0000, color
);
645 /* read/write, conversion */
646 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
|ImageLockModeWrite
, PixelFormat32bppARGB
, &bd
);
650 expect(0xff, ((BYTE
*)bd
.Scan0
)[2]);
651 ((BYTE
*)bd
.Scan0
)[1] = 0x88;
653 /* Areas outside the rectangle appear to be uninitialized */
654 ok(0xc3 != ((BYTE
*)bd
.Scan0
)[2 + bd
.Stride
* 5], "original image bits are readable\n");
656 stat
= GdipBitmapUnlockBits(bm
, &bd
);
660 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
662 expect(0xffff8800, color
);
664 /* write, conversion */
665 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
, PixelFormat32bppARGB
, &bd
);
671 /* This is completely uninitialized. */
672 ok(0xff != ((BYTE
*)bd
.Scan0
)[2], "original image bits are readable\n");
673 ok(0xc3 != ((BYTE
*)bd
.Scan0
)[2 + bd
.Stride
* 5], "original image bits are readable\n");
676 /* Initialize the buffer so the unlock doesn't access undefined memory */
678 memset(((BYTE
*)bd
.Scan0
) + bd
.Stride
* y
, 0, 12);
680 ((BYTE
*)bd
.Scan0
)[0] = 0x12;
681 ((BYTE
*)bd
.Scan0
)[1] = 0x34;
682 ((BYTE
*)bd
.Scan0
)[2] = 0x56;
684 stat
= GdipBitmapUnlockBits(bm
, &bd
);
688 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
690 expect(0xff563412, color
);
692 stat
= GdipBitmapGetPixel(bm
, 2, 8, &color
);
694 expect(0xffc30000, color
);
696 stat
= GdipDisposeImage((GpImage
*)bm
);
698 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
701 /* write, no modification */
702 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
, PixelFormat24bppRGB
, &bd
);
706 stat
= GdipBitmapUnlockBits(bm
, &bd
);
710 /* write, consecutive */
711 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
, PixelFormat24bppRGB
, &bd
);
715 stat
= GdipBitmapUnlockBits(bm
, &bd
);
719 stat
= GdipDisposeImage((GpImage
*)bm
);
721 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
725 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
, PixelFormat24bppRGB
, &bd
);
730 ((char*)bd
.Scan0
)[2] = 0xff;
732 stat
= GdipBitmapUnlockBits(bm
, &bd
);
736 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
738 expect(0xffff0000, color
);
740 stat
= GdipDisposeImage((GpImage
*)bm
);
744 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
746 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
, PixelFormat24bppRGB
, &bd
);
748 stat
= GdipDisposeImage((GpImage
*)bm
);
752 static void test_LockBits_UserBuf(void)
758 const INT WIDTH
= 10, HEIGHT
= 20;
763 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat32bppARGB
, NULL
, &bm
);
766 memset(bits
, 0xaa, sizeof(bits
));
775 bd
.Stride
= WIDTH
* 4;
776 bd
.PixelFormat
= PixelFormat32bppARGB
;
777 bd
.Scan0
= &bits
[2+3*WIDTH
];
778 bd
.Reserved
= 0xaaaaaaaa;
781 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
|ImageLockModeUserInputBuf
, PixelFormat32bppARGB
, &bd
);
784 expect(0xaaaaaaaa, bits
[0]);
785 expect(0, bits
[2+3*WIDTH
]);
787 bits
[2+3*WIDTH
] = 0xdeadbeef;
790 stat
= GdipBitmapUnlockBits(bm
, &bd
);
794 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
799 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeWrite
|ImageLockModeUserInputBuf
, PixelFormat32bppARGB
, &bd
);
802 expect(0xdeadbeef, bits
[2+3*WIDTH
]);
803 bits
[2+3*WIDTH
] = 0x12345678;
806 stat
= GdipBitmapUnlockBits(bm
, &bd
);
810 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
812 expect(0x12345678, color
);
817 stat
= GdipBitmapLockBits(bm
, &rect
, ImageLockModeRead
|ImageLockModeWrite
|ImageLockModeUserInputBuf
, PixelFormat32bppARGB
, &bd
);
820 expect(0x12345678, bits
[2+3*WIDTH
]);
821 bits
[2+3*WIDTH
] = 0xdeadbeef;
824 stat
= GdipBitmapUnlockBits(bm
, &bd
);
828 stat
= GdipBitmapGetPixel(bm
, 2, 3, &color
);
830 expect(0xdeadbeef, color
);
832 stat
= GdipDisposeImage((GpImage
*)bm
);
836 struct BITMAPINFOWITHBITFIELDS
838 BITMAPINFOHEADER bmiHeader
;
842 union BITMAPINFOUNION
845 struct BITMAPINFOWITHBITFIELDS bf
;
848 static void test_GdipCreateBitmapFromHBITMAP(void)
850 GpBitmap
* gpbm
= NULL
;
852 HPALETTE hpal
= NULL
;
855 LOGPALETTE
* LogPal
= NULL
;
857 const REAL WIDTH1
= 5;
858 const REAL HEIGHT1
= 15;
859 const REAL WIDTH2
= 10;
860 const REAL HEIGHT2
= 20;
862 union BITMAPINFOUNION bmi
;
866 stat
= GdipCreateBitmapFromHBITMAP(NULL
, NULL
, NULL
);
867 expect(InvalidParameter
, stat
);
869 hbm
= CreateBitmap(WIDTH1
, HEIGHT1
, 1, 1, NULL
);
870 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, NULL
);
871 expect(InvalidParameter
, stat
);
873 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
875 expect(Ok
, GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
));
876 expectf(WIDTH1
, width
);
877 expectf(HEIGHT1
, height
);
879 GdipDisposeImage((GpImage
*)gpbm
);
882 memset(buff
, 0, sizeof(buff
));
883 hbm
= CreateBitmap(WIDTH2
, HEIGHT2
, 1, 1, &buff
);
884 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
887 expect_rawformat(&ImageFormatMemoryBMP
, (GpImage
*)gpbm
, __LINE__
, FALSE
);
889 expect(Ok
, GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
));
890 expectf(WIDTH2
, width
);
891 expectf(HEIGHT2
, height
);
893 GdipDisposeImage((GpImage
*)gpbm
);
896 hdc
= CreateCompatibleDC(0);
897 ok(hdc
!= NULL
, "CreateCompatibleDC failed\n");
898 bmi
.bi
.bmiHeader
.biSize
= sizeof(bmi
.bi
.bmiHeader
);
899 bmi
.bi
.bmiHeader
.biHeight
= HEIGHT1
;
900 bmi
.bi
.bmiHeader
.biWidth
= WIDTH1
;
901 bmi
.bi
.bmiHeader
.biBitCount
= 24;
902 bmi
.bi
.bmiHeader
.biPlanes
= 1;
903 bmi
.bi
.bmiHeader
.biCompression
= BI_RGB
;
904 bmi
.bi
.bmiHeader
.biClrUsed
= 0;
906 hbm
= CreateDIBSection(hdc
, &bmi
.bi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
907 ok(hbm
!= NULL
, "CreateDIBSection failed\n");
911 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
913 expect(Ok
, GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
));
914 expectf(WIDTH1
, width
);
915 expectf(HEIGHT1
, height
);
918 /* test whether writing to the bitmap affects the original */
919 stat
= GdipBitmapSetPixel(gpbm
, 0, 0, 0xffffffff);
924 GdipDisposeImage((GpImage
*)gpbm
);
927 LogPal
= GdipAlloc(sizeof(LOGPALETTE
));
928 ok(LogPal
!= NULL
, "unable to allocate LOGPALETTE\n");
929 LogPal
->palVersion
= 0x300;
930 LogPal
->palNumEntries
= 1;
931 hpal
= CreatePalette(LogPal
);
932 ok(hpal
!= NULL
, "CreatePalette failed\n");
935 stat
= GdipCreateBitmapFromHBITMAP(hbm
, hpal
, &gpbm
);
939 GdipDisposeImage((GpImage
*)gpbm
);
944 /* 16-bit 555 dib, rgb */
945 bmi
.bi
.bmiHeader
.biBitCount
= 16;
946 bmi
.bi
.bmiHeader
.biCompression
= BI_RGB
;
948 hbm
= CreateDIBSection(hdc
, &bmi
.bi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
949 ok(hbm
!= NULL
, "CreateDIBSection failed\n");
953 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
958 stat
= GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
);
960 expectf(WIDTH1
, width
);
961 expectf(HEIGHT1
, height
);
963 stat
= GdipGetImagePixelFormat((GpImage
*) gpbm
, &format
);
965 expect(PixelFormat16bppRGB555
, format
);
967 GdipDisposeImage((GpImage
*)gpbm
);
971 /* 16-bit 555 dib, with bitfields */
972 bmi
.bi
.bmiHeader
.biSize
= sizeof(bmi
);
973 bmi
.bi
.bmiHeader
.biCompression
= BI_BITFIELDS
;
974 bmi
.bf
.masks
[0] = 0x7c00;
975 bmi
.bf
.masks
[1] = 0x3e0;
976 bmi
.bf
.masks
[2] = 0x1f;
978 hbm
= CreateDIBSection(hdc
, &bmi
.bi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
979 ok(hbm
!= NULL
, "CreateDIBSection failed\n");
983 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
988 stat
= GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
);
990 expectf(WIDTH1
, width
);
991 expectf(HEIGHT1
, height
);
993 stat
= GdipGetImagePixelFormat((GpImage
*) gpbm
, &format
);
995 expect(PixelFormat16bppRGB555
, format
);
997 GdipDisposeImage((GpImage
*)gpbm
);
1001 /* 16-bit 565 dib, with bitfields */
1002 bmi
.bf
.masks
[0] = 0xf800;
1003 bmi
.bf
.masks
[1] = 0x7e0;
1004 bmi
.bf
.masks
[2] = 0x1f;
1006 hbm
= CreateDIBSection(hdc
, &bmi
.bi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
1007 ok(hbm
!= NULL
, "CreateDIBSection failed\n");
1011 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, &gpbm
);
1016 stat
= GdipGetImageDimension((GpImage
*) gpbm
, &width
, &height
);
1018 expectf(WIDTH1
, width
);
1019 expectf(HEIGHT1
, height
);
1021 stat
= GdipGetImagePixelFormat((GpImage
*) gpbm
, &format
);
1023 expect(PixelFormat16bppRGB565
, format
);
1025 GdipDisposeImage((GpImage
*)gpbm
);
1032 static void test_GdipGetImageFlags(void)
1038 img
= (GpImage
*)0xdeadbeef;
1040 stat
= GdipGetImageFlags(NULL
, NULL
);
1041 expect(InvalidParameter
, stat
);
1043 stat
= GdipGetImageFlags(NULL
, &flags
);
1044 expect(InvalidParameter
, stat
);
1046 stat
= GdipGetImageFlags(img
, NULL
);
1047 expect(InvalidParameter
, stat
);
1049 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat1bppIndexed
, NULL
, (GpBitmap
**)&img
);
1051 stat
= GdipGetImageFlags(img
, &flags
);
1053 expect(ImageFlagsHasAlpha
, flags
);
1054 GdipDisposeImage(img
);
1056 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat4bppIndexed
, NULL
, (GpBitmap
**)&img
);
1058 stat
= GdipGetImageFlags(img
, &flags
);
1060 expect(ImageFlagsHasAlpha
, flags
);
1061 GdipDisposeImage(img
);
1063 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat8bppIndexed
, NULL
, (GpBitmap
**)&img
);
1065 stat
= GdipGetImageFlags(img
, &flags
);
1067 expect(ImageFlagsHasAlpha
, flags
);
1068 GdipDisposeImage(img
);
1070 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppGrayScale
, NULL
, (GpBitmap
**)&img
);
1072 stat
= GdipGetImageFlags(img
, &flags
);
1074 expect(ImageFlagsNone
, flags
);
1075 GdipDisposeImage(img
);
1077 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB555
, NULL
, (GpBitmap
**)&img
);
1079 stat
= GdipGetImageFlags(img
, &flags
);
1081 expect(ImageFlagsNone
, flags
);
1082 GdipDisposeImage(img
);
1084 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppRGB565
, NULL
, (GpBitmap
**)&img
);
1086 stat
= GdipGetImageFlags(img
, &flags
);
1088 expect(ImageFlagsNone
, flags
);
1089 GdipDisposeImage(img
);
1091 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat16bppARGB1555
, NULL
, (GpBitmap
**)&img
);
1093 stat
= GdipGetImageFlags(img
, &flags
);
1095 expect(ImageFlagsHasAlpha
, flags
);
1096 GdipDisposeImage(img
);
1098 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB
, NULL
, (GpBitmap
**)&img
);
1100 stat
= GdipGetImageFlags(img
, &flags
);
1102 expect(ImageFlagsNone
, flags
);
1103 GdipDisposeImage(img
);
1105 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppRGB
, NULL
, (GpBitmap
**)&img
);
1107 stat
= GdipGetImageFlags(img
, &flags
);
1109 expect(ImageFlagsNone
, flags
);
1110 GdipDisposeImage(img
);
1112 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppARGB
, NULL
, (GpBitmap
**)&img
);
1114 stat
= GdipGetImageFlags(img
, &flags
);
1116 expect(ImageFlagsHasAlpha
, flags
);
1117 GdipDisposeImage(img
);
1119 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat32bppPARGB
, NULL
, (GpBitmap
**)&img
);
1121 stat
= GdipGetImageFlags(img
, &flags
);
1123 expect(ImageFlagsHasAlpha
, flags
);
1124 GdipDisposeImage(img
);
1126 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat48bppRGB
, NULL
, (GpBitmap
**)&img
);
1130 stat
= GdipGetImageFlags(img
, &flags
);
1132 expect(ImageFlagsNone
, flags
);
1133 GdipDisposeImage(img
);
1136 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppARGB
, NULL
, (GpBitmap
**)&img
);
1141 stat
= GdipGetImageFlags(img
, &flags
);
1143 expect(ImageFlagsHasAlpha
, flags
);
1144 GdipDisposeImage(img
);
1147 stat
= GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat64bppPARGB
, NULL
, (GpBitmap
**)&img
);
1152 stat
= GdipGetImageFlags(img
, &flags
);
1154 expect(ImageFlagsHasAlpha
, flags
);
1155 GdipDisposeImage(img
);
1159 static void test_GdipCloneImage(void)
1165 GpImage
*image_src
, *image_dest
= NULL
;
1166 const INT WIDTH
= 10, HEIGHT
= 20;
1168 /* Create an image, clone it, delete the original, make sure the copy works */
1169 stat
= GdipCreateBitmapFromScan0(WIDTH
, HEIGHT
, 0, PixelFormat24bppRGB
, NULL
, &bm
);
1171 expect_rawformat(&ImageFormatMemoryBMP
, (GpImage
*)bm
, __LINE__
, FALSE
);
1173 image_src
= ((GpImage
*)bm
);
1174 stat
= GdipCloneImage(image_src
, &image_dest
);
1176 expect_rawformat(&ImageFormatMemoryBMP
, image_dest
, __LINE__
, FALSE
);
1178 stat
= GdipDisposeImage((GpImage
*)bm
);
1180 stat
= GdipGetImageBounds(image_dest
, &rectF
, &unit
);
1183 /* Treat FP values carefully */
1184 expectf((REAL
)WIDTH
, rectF
.Width
);
1185 expectf((REAL
)HEIGHT
, rectF
.Height
);
1187 stat
= GdipDisposeImage(image_dest
);
1191 static void test_testcontrol(void)
1197 stat
= GdipTestControl(TestControlGetBuildNumber
, ¶m
);
1199 ok(param
!= 0, "Build number expected, got %u\n", param
);
1202 static void test_fromhicon(void)
1204 static const BYTE bmp_bits
[1024];
1205 HBITMAP hbmMask
, hbmColor
;
1209 GpBitmap
*bitmap
= NULL
;
1215 stat
= GdipCreateBitmapFromHICON(NULL
, NULL
);
1216 expect(InvalidParameter
, stat
);
1217 stat
= GdipCreateBitmapFromHICON(NULL
, &bitmap
);
1218 expect(InvalidParameter
, stat
);
1220 /* color icon 1 bit */
1221 hbmMask
= CreateBitmap(16, 16, 1, 1, bmp_bits
);
1222 ok(hbmMask
!= 0, "CreateBitmap failed\n");
1223 hbmColor
= CreateBitmap(16, 16, 1, 1, bmp_bits
);
1224 ok(hbmColor
!= 0, "CreateBitmap failed\n");
1228 info
.hbmMask
= hbmMask
;
1229 info
.hbmColor
= hbmColor
;
1230 hIcon
= CreateIconIndirect(&info
);
1231 ok(hIcon
!= 0, "CreateIconIndirect failed\n");
1232 DeleteObject(hbmMask
);
1233 DeleteObject(hbmColor
);
1235 stat
= GdipCreateBitmapFromHICON(hIcon
, &bitmap
);
1237 broken(stat
== InvalidParameter
), /* Win98 */
1238 "Expected Ok, got %.8x\n", stat
);
1240 /* check attributes */
1241 stat
= GdipGetImageHeight((GpImage
*)bitmap
, &dim
);
1244 stat
= GdipGetImageWidth((GpImage
*)bitmap
, &dim
);
1247 stat
= GdipGetImageType((GpImage
*)bitmap
, &type
);
1249 expect(ImageTypeBitmap
, type
);
1250 stat
= GdipGetImagePixelFormat((GpImage
*)bitmap
, &format
);
1252 expect(PixelFormat32bppARGB
, format
);
1254 expect_rawformat(&ImageFormatMemoryBMP
, (GpImage
*)bitmap
, __LINE__
, FALSE
);
1255 GdipDisposeImage((GpImage
*)bitmap
);
1259 /* color icon 8 bpp */
1260 hbmMask
= CreateBitmap(16, 16, 1, 8, bmp_bits
);
1261 ok(hbmMask
!= 0, "CreateBitmap failed\n");
1262 hbmColor
= CreateBitmap(16, 16, 1, 8, bmp_bits
);
1263 ok(hbmColor
!= 0, "CreateBitmap failed\n");
1267 info
.hbmMask
= hbmMask
;
1268 info
.hbmColor
= hbmColor
;
1269 hIcon
= CreateIconIndirect(&info
);
1270 ok(hIcon
!= 0, "CreateIconIndirect failed\n");
1271 DeleteObject(hbmMask
);
1272 DeleteObject(hbmColor
);
1274 stat
= GdipCreateBitmapFromHICON(hIcon
, &bitmap
);
1277 /* check attributes */
1278 stat
= GdipGetImageHeight((GpImage
*)bitmap
, &dim
);
1281 stat
= GdipGetImageWidth((GpImage
*)bitmap
, &dim
);
1284 stat
= GdipGetImageType((GpImage
*)bitmap
, &type
);
1286 expect(ImageTypeBitmap
, type
);
1287 stat
= GdipGetImagePixelFormat((GpImage
*)bitmap
, &format
);
1289 expect(PixelFormat32bppARGB
, format
);
1291 expect_rawformat(&ImageFormatMemoryBMP
, (GpImage
*)bitmap
, __LINE__
, FALSE
);
1292 GdipDisposeImage((GpImage
*)bitmap
);
1298 static const unsigned char pngimage
[285] = {
1299 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
1300 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
1301 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
1302 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
1303 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
1304 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
1305 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
1308 static const unsigned char gifimage
[35] = {
1309 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
1310 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
1314 static const unsigned char bmpimage
[66] = {
1315 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
1316 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
1317 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
1318 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
1322 static const unsigned char jpgimage
[285] = {
1323 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
1324 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
1325 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
1326 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
1327 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
1328 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
1329 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
1330 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1331 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
1332 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
1333 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
1334 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1335 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
1336 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
1337 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
1338 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
1339 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
1340 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
1342 /* 1x1 pixel tiff */
1343 static const unsigned char tiffimage
[] = {
1344 0x49,0x49,0x2a,0x00,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0xfe,0x00,
1345 0x04,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x03,0x00,0x01,0x00,
1346 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1347 0x00,0x00,0x02,0x01,0x03,0x00,0x03,0x00,0x00,0x00,0xd2,0x00,0x00,0x00,0x03,0x01,
1348 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x01,0x03,0x00,0x01,0x00,
1349 0x00,0x00,0x02,0x00,0x00,0x00,0x0d,0x01,0x02,0x00,0x1b,0x00,0x00,0x00,0xd8,0x00,
1350 0x00,0x00,0x11,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x12,0x01,
1351 0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x01,0x03,0x00,0x01,0x00,
1352 0x00,0x00,0x03,0x00,0x00,0x00,0x16,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x40,0x00,
1353 0x00,0x00,0x17,0x01,0x04,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x1a,0x01,
1354 0x05,0x00,0x01,0x00,0x00,0x00,0xf4,0x00,0x00,0x00,0x1b,0x01,0x05,0x00,0x01,0x00,
1355 0x00,0x00,0xfc,0x00,0x00,0x00,0x1c,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x01,0x00,
1356 0x00,0x00,0x28,0x01,0x03,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
1357 0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x2f,0x68,0x6f,0x6d,0x65,0x2f,0x6d,0x65,
1358 0x68,0x2f,0x44,0x65,0x73,0x6b,0x74,0x6f,0x70,0x2f,0x74,0x65,0x73,0x74,0x2e,0x74,
1359 0x69,0x66,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x48,
1362 /* 320x320 twip wmf */
1363 static const unsigned char wmfimage
[180] = {
1364 0xd7,0xcd,0xc6,0x9a,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0x40,0x01,0xa0,0x05,
1365 0x00,0x00,0x00,0x00,0xb1,0x52,0x01,0x00,0x09,0x00,0x00,0x03,0x4f,0x00,0x00,0x00,
1366 0x0f,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x0b,0x02,0x00,0x00,
1367 0x00,0x00,0x05,0x00,0x00,0x00,0x0c,0x02,0x40,0x01,0x40,0x01,0x04,0x00,0x00,0x00,
1368 0x02,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x04,0x01,0x0d,0x00,0x08,0x00,0x00,0x00,
1369 0xfa,0x02,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
1370 0x2d,0x01,0x00,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,0x01,0x00,0x00,0x00,0x00,0x00,
1371 0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x01,0x00,0x07,0x00,0x00,0x00,0xfc,0x02,
1372 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x2d,0x01,0x02,0x00,
1373 0x07,0x00,0x00,0x00,0x1b,0x04,0x40,0x01,0x40,0x01,0x00,0x00,0x00,0x00,0x04,0x00,
1374 0x00,0x00,0xf0,0x01,0x00,0x00,0x04,0x00,0x00,0x00,0xf0,0x01,0x01,0x00,0x03,0x00,
1377 static void test_getrawformat(void)
1379 test_bufferrawformat((void*)pngimage
, sizeof(pngimage
), &ImageFormatPNG
, __LINE__
, FALSE
);
1380 test_bufferrawformat((void*)gifimage
, sizeof(gifimage
), &ImageFormatGIF
, __LINE__
, FALSE
);
1381 test_bufferrawformat((void*)bmpimage
, sizeof(bmpimage
), &ImageFormatBMP
, __LINE__
, FALSE
);
1382 test_bufferrawformat((void*)jpgimage
, sizeof(jpgimage
), &ImageFormatJPEG
, __LINE__
, FALSE
);
1383 test_bufferrawformat((void*)tiffimage
, sizeof(tiffimage
), &ImageFormatTIFF
, __LINE__
, FALSE
);
1384 test_bufferrawformat((void*)wmfimage
, sizeof(wmfimage
), &ImageFormatWMF
, __LINE__
, FALSE
);
1387 static void test_loadwmf(void)
1398 MetafileHeader header
;
1400 hglob
= GlobalAlloc (0, sizeof(wmfimage
));
1401 data
= GlobalLock (hglob
);
1402 memcpy(data
, wmfimage
, sizeof(wmfimage
));
1403 GlobalUnlock(hglob
); data
= NULL
;
1405 hres
= CreateStreamOnHGlobal(hglob
, TRUE
, &stream
);
1406 ok(hres
== S_OK
, "Failed to create a stream\n");
1407 if(hres
!= S_OK
) return;
1409 stat
= GdipLoadImageFromStream(stream
, &img
);
1410 ok(stat
== Ok
, "Failed to create a Bitmap\n");
1412 IStream_Release(stream
);
1416 IStream_Release(stream
);
1418 stat
= GdipGetImageBounds(img
, &bounds
, &unit
);
1420 todo_wine
expect(UnitPixel
, unit
);
1421 expectf(0.0, bounds
.X
);
1422 expectf(0.0, bounds
.Y
);
1423 todo_wine
expectf(320.0, bounds
.Width
);
1424 todo_wine
expectf(320.0, bounds
.Height
);
1426 stat
= GdipGetImageHorizontalResolution(img
, &res
);
1428 todo_wine
expectf(1440.0, res
);
1430 stat
= GdipGetImageVerticalResolution(img
, &res
);
1432 todo_wine
expectf(1440.0, res
);
1434 memset(&header
, 0, sizeof(header
));
1435 stat
= GdipGetMetafileHeaderFromMetafile((GpMetafile
*)img
, &header
);
1439 todo_wine
expect(MetafileTypeWmfPlaceable
, header
.Type
);
1440 todo_wine
expect(sizeof(wmfimage
)-sizeof(WmfPlaceableFileHeader
), header
.Size
);
1441 todo_wine
expect(0x300, header
.Version
);
1442 expect(0, header
.EmfPlusFlags
);
1443 todo_wine
expectf(1440.0, header
.DpiX
);
1444 todo_wine
expectf(1440.0, header
.DpiY
);
1445 expect(0, header
.X
);
1446 expect(0, header
.Y
);
1447 todo_wine
expect(320, header
.Width
);
1448 todo_wine
expect(320, header
.Height
);
1449 todo_wine
expect(1, U(header
).WmfHeader
.mtType
);
1450 expect(0, header
.EmfPlusHeaderSize
);
1451 expect(0, header
.LogicalDpiX
);
1452 expect(0, header
.LogicalDpiY
);
1455 GdipDisposeImage(img
);
1458 static void test_createfromwmf(void)
1466 MetafileHeader header
;
1468 hwmf
= SetMetaFileBitsEx(sizeof(wmfimage
)-sizeof(WmfPlaceableFileHeader
),
1469 wmfimage
+sizeof(WmfPlaceableFileHeader
));
1470 ok(hwmf
!= 0, "SetMetaFileBitsEx failed\n");
1472 stat
= GdipCreateMetafileFromWmf(hwmf
, TRUE
,
1473 (WmfPlaceableFileHeader
*)wmfimage
, (GpMetafile
**)&img
);
1476 stat
= GdipGetImageBounds(img
, &bounds
, &unit
);
1478 expect(UnitPixel
, unit
);
1479 expectf(0.0, bounds
.X
);
1480 expectf(0.0, bounds
.Y
);
1481 expectf(320.0, bounds
.Width
);
1482 expectf(320.0, bounds
.Height
);
1484 stat
= GdipGetImageHorizontalResolution(img
, &res
);
1486 expectf(1440.0, res
);
1488 stat
= GdipGetImageVerticalResolution(img
, &res
);
1490 expectf(1440.0, res
);
1492 memset(&header
, 0, sizeof(header
));
1493 stat
= GdipGetMetafileHeaderFromMetafile((GpMetafile
*)img
, &header
);
1497 todo_wine
expect(MetafileTypeWmfPlaceable
, header
.Type
);
1498 todo_wine
expect(sizeof(wmfimage
)-sizeof(WmfPlaceableFileHeader
), header
.Size
);
1499 todo_wine
expect(0x300, header
.Version
);
1500 expect(0, header
.EmfPlusFlags
);
1501 todo_wine
expectf(1440.0, header
.DpiX
);
1502 todo_wine
expectf(1440.0, header
.DpiY
);
1503 expect(0, header
.X
);
1504 expect(0, header
.Y
);
1505 todo_wine
expect(320, header
.Width
);
1506 todo_wine
expect(320, header
.Height
);
1507 todo_wine
expect(1, U(header
).WmfHeader
.mtType
);
1508 expect(0, header
.EmfPlusHeaderSize
);
1509 expect(0, header
.LogicalDpiX
);
1510 expect(0, header
.LogicalDpiY
);
1513 GdipDisposeImage(img
);
1516 static void test_resolution(void)
1522 int screenxres
, screenyres
;
1525 stat
= GdipCreateBitmapFromScan0(1, 1, 32, PixelFormat24bppRGB
, NULL
, &bitmap
);
1528 /* test invalid values */
1529 stat
= GdipGetImageHorizontalResolution(NULL
, &res
);
1530 expect(InvalidParameter
, stat
);
1532 stat
= GdipGetImageHorizontalResolution((GpImage
*)bitmap
, NULL
);
1533 expect(InvalidParameter
, stat
);
1535 stat
= GdipGetImageVerticalResolution(NULL
, &res
);
1536 expect(InvalidParameter
, stat
);
1538 stat
= GdipGetImageVerticalResolution((GpImage
*)bitmap
, NULL
);
1539 expect(InvalidParameter
, stat
);
1541 stat
= GdipBitmapSetResolution(NULL
, 96.0, 96.0);
1542 expect(InvalidParameter
, stat
);
1544 stat
= GdipBitmapSetResolution(bitmap
, 0.0, 0.0);
1545 expect(InvalidParameter
, stat
);
1547 /* defaults to screen resolution */
1548 screendc
= GetDC(0);
1550 screenxres
= GetDeviceCaps(screendc
, LOGPIXELSX
);
1551 screenyres
= GetDeviceCaps(screendc
, LOGPIXELSY
);
1553 ReleaseDC(0, screendc
);
1555 stat
= GdipGetImageHorizontalResolution((GpImage
*)bitmap
, &res
);
1557 expectf((REAL
)screenxres
, res
);
1559 stat
= GdipGetImageVerticalResolution((GpImage
*)bitmap
, &res
);
1561 expectf((REAL
)screenyres
, res
);
1563 /* test changing the resolution */
1564 stat
= GdipBitmapSetResolution(bitmap
, screenxres
*2.0, screenyres
*3.0);
1567 stat
= GdipGetImageHorizontalResolution((GpImage
*)bitmap
, &res
);
1569 expectf(screenxres
*2.0, res
);
1571 stat
= GdipGetImageVerticalResolution((GpImage
*)bitmap
, &res
);
1573 expectf(screenyres
*3.0, res
);
1575 stat
= GdipDisposeImage((GpImage
*)bitmap
);
1579 static void test_createhbitmap(void)
1583 HBITMAP hbitmap
, oldhbitmap
;
1590 memset(bits
, 0x68, 640);
1593 stat
= GdipCreateBitmapFromScan0(10, 20, 32, PixelFormat24bppRGB
, bits
, &bitmap
);
1596 /* test NULL values */
1597 stat
= GdipCreateHBITMAPFromBitmap(NULL
, &hbitmap
, 0);
1598 expect(InvalidParameter
, stat
);
1600 stat
= GdipCreateHBITMAPFromBitmap(bitmap
, NULL
, 0);
1601 expect(InvalidParameter
, stat
);
1603 /* create HBITMAP */
1604 stat
= GdipCreateHBITMAPFromBitmap(bitmap
, &hbitmap
, 0);
1609 ret
= GetObjectA(hbitmap
, sizeof(BITMAP
), &bm
);
1610 expect(sizeof(BITMAP
), ret
);
1612 expect(0, bm
.bmType
);
1613 expect(10, bm
.bmWidth
);
1614 expect(20, bm
.bmHeight
);
1615 expect(40, bm
.bmWidthBytes
);
1616 expect(1, bm
.bmPlanes
);
1617 expect(32, bm
.bmBitsPixel
);
1618 ok(bm
.bmBits
!= NULL
, "got DDB, expected DIB\n");
1622 DWORD val
= *(DWORD
*)bm
.bmBits
;
1623 ok(val
== 0xff686868, "got %x, expected 0xff686868\n", val
);
1626 hdc
= CreateCompatibleDC(NULL
);
1628 oldhbitmap
= SelectObject(hdc
, hbitmap
);
1629 pixel
= GetPixel(hdc
, 5, 5);
1630 SelectObject(hdc
, oldhbitmap
);
1634 expect(0x686868, pixel
);
1636 DeleteObject(hbitmap
);
1639 stat
= GdipDisposeImage((GpImage
*)bitmap
);
1642 /* create alpha Bitmap */
1643 stat
= GdipCreateBitmapFromScan0(8, 20, 32, PixelFormat32bppARGB
, bits
, &bitmap
);
1646 /* create HBITMAP */
1647 stat
= GdipCreateHBITMAPFromBitmap(bitmap
, &hbitmap
, 0);
1652 ret
= GetObjectA(hbitmap
, sizeof(BITMAP
), &bm
);
1653 expect(sizeof(BITMAP
), ret
);
1655 expect(0, bm
.bmType
);
1656 expect(8, bm
.bmWidth
);
1657 expect(20, bm
.bmHeight
);
1658 expect(32, bm
.bmWidthBytes
);
1659 expect(1, bm
.bmPlanes
);
1660 expect(32, bm
.bmBitsPixel
);
1661 ok(bm
.bmBits
!= NULL
, "got DDB, expected DIB\n");
1665 DWORD val
= *(DWORD
*)bm
.bmBits
;
1666 ok(val
== 0x682a2a2a, "got %x, expected 0x682a2a2a\n", val
);
1669 hdc
= CreateCompatibleDC(NULL
);
1671 oldhbitmap
= SelectObject(hdc
, hbitmap
);
1672 pixel
= GetPixel(hdc
, 5, 5);
1673 SelectObject(hdc
, oldhbitmap
);
1677 expect(0x2a2a2a, pixel
);
1679 DeleteObject(hbitmap
);
1682 stat
= GdipDisposeImage((GpImage
*)bitmap
);
1686 static void test_getthumbnail(void)
1689 GpImage
*bitmap1
, *bitmap2
;
1692 stat
= GdipGetImageThumbnail(NULL
, 0, 0, &bitmap2
, NULL
, NULL
);
1693 expect(InvalidParameter
, stat
);
1695 stat
= GdipCreateBitmapFromScan0(128, 128, 0, PixelFormat32bppRGB
, NULL
, (GpBitmap
**)&bitmap1
);
1698 stat
= GdipGetImageThumbnail(bitmap1
, 0, 0, NULL
, NULL
, NULL
);
1699 expect(InvalidParameter
, stat
);
1701 stat
= GdipGetImageThumbnail(bitmap1
, 0, 0, &bitmap2
, NULL
, NULL
);
1706 stat
= GdipGetImageWidth(bitmap2
, &width
);
1710 stat
= GdipGetImageHeight(bitmap2
, &height
);
1712 expect(120, height
);
1714 GdipDisposeImage(bitmap2
);
1717 GdipDisposeImage(bitmap1
);
1720 stat
= GdipCreateBitmapFromScan0(64, 128, 0, PixelFormat32bppRGB
, NULL
, (GpBitmap
**)&bitmap1
);
1723 stat
= GdipGetImageThumbnail(bitmap1
, 32, 32, &bitmap2
, NULL
, NULL
);
1728 stat
= GdipGetImageWidth(bitmap2
, &width
);
1732 stat
= GdipGetImageHeight(bitmap2
, &height
);
1736 GdipDisposeImage(bitmap2
);
1739 stat
= GdipGetImageThumbnail(bitmap1
, 0, 0, &bitmap2
, NULL
, NULL
);
1744 stat
= GdipGetImageWidth(bitmap2
, &width
);
1748 stat
= GdipGetImageHeight(bitmap2
, &height
);
1750 expect(120, height
);
1752 GdipDisposeImage(bitmap2
);
1755 GdipDisposeImage(bitmap1
);
1758 static void test_getsetpixel(void)
1763 BYTE bits
[16] = {0x00,0x00,0x00,0x00, 0x00,0xff,0xff,0x00,
1764 0xff,0x00,0x00,0x00, 0xff,0xff,0xff,0x00};
1766 stat
= GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB
, bits
, &bitmap
);
1769 /* null parameters */
1770 stat
= GdipBitmapGetPixel(NULL
, 1, 1, &color
);
1771 expect(InvalidParameter
, stat
);
1773 stat
= GdipBitmapGetPixel(bitmap
, 1, 1, NULL
);
1774 expect(InvalidParameter
, stat
);
1776 stat
= GdipBitmapSetPixel(NULL
, 1, 1, 0);
1777 expect(InvalidParameter
, stat
);
1780 stat
= GdipBitmapGetPixel(bitmap
, -1, 1, &color
);
1781 expect(InvalidParameter
, stat
);
1783 stat
= GdipBitmapSetPixel(bitmap
, -1, 1, 0);
1784 expect(InvalidParameter
, stat
);
1786 stat
= GdipBitmapGetPixel(bitmap
, 1, -1, &color
);
1787 ok(stat
== InvalidParameter
||
1788 broken(stat
== Ok
), /* Older gdiplus */
1789 "Expected InvalidParameter, got %.8x\n", stat
);
1791 if (0) /* crashes some gdiplus implementations */
1793 stat
= GdipBitmapSetPixel(bitmap
, 1, -1, 0);
1794 ok(stat
== InvalidParameter
||
1795 broken(stat
== Ok
), /* Older gdiplus */
1796 "Expected InvalidParameter, got %.8x\n", stat
);
1799 stat
= GdipBitmapGetPixel(bitmap
, 2, 1, &color
);
1800 expect(InvalidParameter
, stat
);
1802 stat
= GdipBitmapSetPixel(bitmap
, 2, 1, 0);
1803 expect(InvalidParameter
, stat
);
1805 stat
= GdipBitmapGetPixel(bitmap
, 1, 2, &color
);
1806 expect(InvalidParameter
, stat
);
1808 stat
= GdipBitmapSetPixel(bitmap
, 1, 2, 0);
1809 expect(InvalidParameter
, stat
);
1812 stat
= GdipBitmapGetPixel(bitmap
, 1, 1, &color
);
1814 expect(0xffffffff, color
);
1816 stat
= GdipBitmapGetPixel(bitmap
, 0, 1, &color
);
1818 expect(0xff0000ff, color
);
1820 stat
= GdipBitmapSetPixel(bitmap
, 1, 1, 0xff676869);
1823 stat
= GdipBitmapSetPixel(bitmap
, 0, 0, 0xff474849);
1826 stat
= GdipBitmapGetPixel(bitmap
, 1, 1, &color
);
1828 expect(0xff676869, color
);
1830 stat
= GdipBitmapGetPixel(bitmap
, 0, 0, &color
);
1832 expect(0xff474849, color
);
1834 stat
= GdipDisposeImage((GpImage
*)bitmap
);
1838 static void check_halftone_palette(ColorPalette
*palette
)
1840 static const BYTE halftone_values
[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1843 for (i
=0; i
<palette
->Count
; i
++)
1845 ARGB expected
=0xff000000;
1848 if (i
&1) expected
|= 0x800000;
1849 if (i
&2) expected
|= 0x8000;
1850 if (i
&4) expected
|= 0x80;
1854 expected
= 0xffc0c0c0;
1858 if (i
&1) expected
|= 0xff0000;
1859 if (i
&2) expected
|= 0xff00;
1860 if (i
&4) expected
|= 0xff;
1864 expected
= 0x00000000;
1868 expected
|= halftone_values
[(i
-40)%6];
1869 expected
|= halftone_values
[((i
-40)/6)%6] << 8;
1870 expected
|= halftone_values
[((i
-40)/36)%6] << 16;
1872 ok(expected
== palette
->Entries
[i
], "Expected %.8x, got %.8x, i=%u/%u\n",
1873 expected
, palette
->Entries
[i
], i
, palette
->Count
);
1877 static void test_palette(void)
1883 ColorPalette
*palette
=(ColorPalette
*)buffer
;
1884 ARGB
*entries
= palette
->Entries
;
1887 /* test initial palette from non-indexed bitmap */
1888 stat
= GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat32bppRGB
, NULL
, &bitmap
);
1891 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
1893 expect(sizeof(UINT
)*2+sizeof(ARGB
), size
);
1895 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
1897 expect(0, palette
->Count
);
1899 /* test setting palette on not-indexed bitmap */
1902 stat
= GdipSetImagePalette((GpImage
*)bitmap
, palette
);
1905 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
1907 expect(sizeof(UINT
)*2+sizeof(ARGB
)*3, size
);
1909 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
1911 expect(3, palette
->Count
);
1913 GdipDisposeImage((GpImage
*)bitmap
);
1915 /* test initial palette on 1-bit bitmap */
1916 stat
= GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat1bppIndexed
, NULL
, &bitmap
);
1919 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
1921 expect(sizeof(UINT
)*2+sizeof(ARGB
)*2, size
);
1923 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
1925 expect(PaletteFlagsGrayScale
, palette
->Flags
);
1926 expect(2, palette
->Count
);
1928 expect(0xff000000, entries
[0]);
1929 expect(0xffffffff, entries
[1]);
1931 /* test getting/setting pixels */
1932 stat
= GdipBitmapGetPixel(bitmap
, 0, 0, &color
);
1934 expect(0xff000000, color
);
1936 stat
= GdipBitmapSetPixel(bitmap
, 0, 1, 0xffffffff);
1938 broken(stat
== InvalidParameter
) /* pre-win7 */, "stat=%.8x\n", stat
);
1942 stat
= GdipBitmapGetPixel(bitmap
, 0, 1, &color
);
1944 expect(0xffffffff, color
);
1947 GdipDisposeImage((GpImage
*)bitmap
);
1949 /* test initial palette on 4-bit bitmap */
1950 stat
= GdipCreateBitmapFromScan0(2, 2, 4, PixelFormat4bppIndexed
, NULL
, &bitmap
);
1953 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
1955 expect(sizeof(UINT
)*2+sizeof(ARGB
)*16, size
);
1957 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
1959 expect(0, palette
->Flags
);
1960 expect(16, palette
->Count
);
1962 check_halftone_palette(palette
);
1964 /* test getting/setting pixels */
1965 stat
= GdipBitmapGetPixel(bitmap
, 0, 0, &color
);
1967 expect(0xff000000, color
);
1969 stat
= GdipBitmapSetPixel(bitmap
, 0, 1, 0xffff00ff);
1971 broken(stat
== InvalidParameter
) /* pre-win7 */, "stat=%.8x\n", stat
);
1975 stat
= GdipBitmapGetPixel(bitmap
, 0, 1, &color
);
1977 expect(0xffff00ff, color
);
1980 GdipDisposeImage((GpImage
*)bitmap
);
1982 /* test initial palette on 8-bit bitmap */
1983 stat
= GdipCreateBitmapFromScan0(2, 2, 8, PixelFormat8bppIndexed
, NULL
, &bitmap
);
1986 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
1988 expect(sizeof(UINT
)*2+sizeof(ARGB
)*256, size
);
1990 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
1992 expect(PaletteFlagsHalftone
, palette
->Flags
);
1993 expect(256, palette
->Count
);
1995 check_halftone_palette(palette
);
1997 /* test getting/setting pixels */
1998 stat
= GdipBitmapGetPixel(bitmap
, 0, 0, &color
);
2000 expect(0xff000000, color
);
2002 stat
= GdipBitmapSetPixel(bitmap
, 0, 1, 0xffcccccc);
2004 broken(stat
== InvalidParameter
) /* pre-win7 */, "stat=%.8x\n", stat
);
2008 stat
= GdipBitmapGetPixel(bitmap
, 0, 1, &color
);
2010 expect(0xffcccccc, color
);
2013 /* test setting/getting a different palette */
2014 entries
[1] = 0xffcccccc;
2016 stat
= GdipSetImagePalette((GpImage
*)bitmap
, palette
);
2021 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
2023 expect(sizeof(UINT
)*2+sizeof(ARGB
)*256, size
);
2025 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
2027 expect(PaletteFlagsHalftone
, palette
->Flags
);
2028 expect(256, palette
->Count
);
2029 expect(0xffcccccc, entries
[1]);
2031 /* test count < 256 */
2032 palette
->Flags
= 12345;
2035 stat
= GdipSetImagePalette((GpImage
*)bitmap
, palette
);
2039 entries
[3] = 0xdeadbeef;
2041 stat
= GdipGetImagePaletteSize((GpImage
*)bitmap
, &size
);
2043 expect(sizeof(UINT
)*2+sizeof(ARGB
)*3, size
);
2045 stat
= GdipGetImagePalette((GpImage
*)bitmap
, palette
, size
);
2047 expect(12345, palette
->Flags
);
2048 expect(3, palette
->Count
);
2049 expect(0xffcccccc, entries
[1]);
2050 expect(0xdeadbeef, entries
[3]);
2052 /* test count > 256 */
2053 palette
->Count
= 257;
2055 stat
= GdipSetImagePalette((GpImage
*)bitmap
, palette
);
2056 ok(stat
== InvalidParameter
||
2057 broken(stat
== Ok
), /* Old gdiplus behavior */
2058 "Expected %.8x, got %.8x\n", InvalidParameter
, stat
);
2060 GdipDisposeImage((GpImage
*)bitmap
);
2063 static void test_colormatrix(void)
2066 ColorMatrix colormatrix
, graymatrix
;
2067 GpImageAttributes
*imageattr
;
2068 const ColorMatrix identity
= {{
2069 {1.0,0.0,0.0,0.0,0.0},
2070 {0.0,1.0,0.0,0.0,0.0},
2071 {0.0,0.0,1.0,0.0,0.0},
2072 {0.0,0.0,0.0,1.0,0.0},
2073 {0.0,0.0,0.0,0.0,1.0}}};
2074 const ColorMatrix double_red
= {{
2075 {2.0,0.0,0.0,0.0,0.0},
2076 {0.0,1.0,0.0,0.0,0.0},
2077 {0.0,0.0,1.0,0.0,0.0},
2078 {0.0,0.0,0.0,1.0,0.0},
2079 {0.0,0.0,0.0,0.0,1.0}}};
2080 const ColorMatrix asymmetric
= {{
2081 {0.0,1.0,0.0,0.0,0.0},
2082 {0.0,0.0,1.0,0.0,0.0},
2083 {0.0,0.0,0.0,1.0,0.0},
2084 {1.0,0.0,0.0,0.0,0.0},
2085 {0.0,0.0,0.0,0.0,1.0}}};
2086 GpBitmap
*bitmap1
, *bitmap2
;
2087 GpGraphics
*graphics
;
2090 colormatrix
= identity
;
2091 graymatrix
= identity
;
2093 stat
= GdipSetImageAttributesColorMatrix(NULL
, ColorAdjustTypeDefault
,
2094 TRUE
, &colormatrix
, &graymatrix
, ColorMatrixFlagsDefault
);
2095 expect(InvalidParameter
, stat
);
2097 stat
= GdipCreateImageAttributes(&imageattr
);
2100 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2101 TRUE
, &colormatrix
, NULL
, ColorMatrixFlagsDefault
);
2104 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2105 TRUE
, NULL
, NULL
, ColorMatrixFlagsDefault
);
2106 expect(InvalidParameter
, stat
);
2108 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2109 TRUE
, &colormatrix
, &graymatrix
, ColorMatrixFlagsDefault
);
2112 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2113 TRUE
, &colormatrix
, NULL
, ColorMatrixFlagsSkipGrays
);
2116 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2117 TRUE
, &colormatrix
, NULL
, ColorMatrixFlagsAltGray
);
2118 expect(InvalidParameter
, stat
);
2120 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2121 TRUE
, &colormatrix
, &graymatrix
, ColorMatrixFlagsAltGray
);
2124 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2125 TRUE
, &colormatrix
, &graymatrix
, 3);
2126 expect(InvalidParameter
, stat
);
2128 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeCount
,
2129 TRUE
, &colormatrix
, &graymatrix
, ColorMatrixFlagsDefault
);
2130 expect(InvalidParameter
, stat
);
2132 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeAny
,
2133 TRUE
, &colormatrix
, &graymatrix
, ColorMatrixFlagsDefault
);
2134 expect(InvalidParameter
, stat
);
2136 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2137 FALSE
, NULL
, NULL
, ColorMatrixFlagsDefault
);
2140 /* Drawing a bitmap transforms the colors */
2141 colormatrix
= double_red
;
2142 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2143 TRUE
, &colormatrix
, NULL
, ColorMatrixFlagsDefault
);
2146 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB
, NULL
, &bitmap1
);
2149 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppARGB
, NULL
, &bitmap2
);
2152 stat
= GdipBitmapSetPixel(bitmap1
, 0, 0, 0xff40ccee);
2155 stat
= GdipGetImageGraphicsContext((GpImage
*)bitmap2
, &graphics
);
2158 stat
= GdipDrawImageRectRectI(graphics
, (GpImage
*)bitmap1
, 0,0,1,1, 0,0,1,1,
2159 UnitPixel
, imageattr
, NULL
, NULL
);
2162 stat
= GdipBitmapGetPixel(bitmap2
, 0, 0, &color
);
2164 expect(0xff80ccee, color
);
2166 colormatrix
= asymmetric
;
2167 stat
= GdipSetImageAttributesColorMatrix(imageattr
, ColorAdjustTypeDefault
,
2168 TRUE
, &colormatrix
, NULL
, ColorMatrixFlagsDefault
);
2171 stat
= GdipBitmapSetPixel(bitmap2
, 0, 0, 0);
2174 stat
= GdipDrawImageRectRectI(graphics
, (GpImage
*)bitmap1
, 0,0,1,1, 0,0,1,1,
2175 UnitPixel
, imageattr
, NULL
, NULL
);
2178 stat
= GdipBitmapGetPixel(bitmap2
, 0, 0, &color
);
2180 ok(color_match(0xeeff40cc, color
, 3), "expected 0xeeff40cc, got 0x%08x\n", color
);
2182 GdipDeleteGraphics(graphics
);
2183 GdipDisposeImage((GpImage
*)bitmap1
);
2184 GdipDisposeImage((GpImage
*)bitmap2
);
2185 GdipDisposeImageAttributes(imageattr
);
2188 static void test_gamma(void)
2191 GpImageAttributes
*imageattr
;
2192 GpBitmap
*bitmap1
, *bitmap2
;
2193 GpGraphics
*graphics
;
2196 stat
= GdipSetImageAttributesGamma(NULL
, ColorAdjustTypeDefault
, TRUE
, 1.0);
2197 expect(InvalidParameter
, stat
);
2199 stat
= GdipCreateImageAttributes(&imageattr
);
2202 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, TRUE
, 1.0);
2205 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeAny
, TRUE
, 1.0);
2206 expect(InvalidParameter
, stat
);
2208 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, TRUE
, -1.0);
2209 expect(InvalidParameter
, stat
);
2211 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, TRUE
, 0.0);
2212 expect(InvalidParameter
, stat
);
2214 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, TRUE
, 0.5);
2217 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, FALSE
, 0.0);
2220 /* Drawing a bitmap transforms the colors */
2221 stat
= GdipSetImageAttributesGamma(imageattr
, ColorAdjustTypeDefault
, TRUE
, 3.0);
2224 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB
, NULL
, &bitmap1
);
2227 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB
, NULL
, &bitmap2
);
2230 stat
= GdipBitmapSetPixel(bitmap1
, 0, 0, 0xff80ffff);
2233 stat
= GdipGetImageGraphicsContext((GpImage
*)bitmap2
, &graphics
);
2236 stat
= GdipDrawImageRectRectI(graphics
, (GpImage
*)bitmap1
, 0,0,1,1, 0,0,1,1,
2237 UnitPixel
, imageattr
, NULL
, NULL
);
2240 stat
= GdipBitmapGetPixel(bitmap2
, 0, 0, &color
);
2242 ok(color_match(0xff20ffff, color
, 1), "Expected ff20ffff, got %.8x\n", color
);
2244 GdipDeleteGraphics(graphics
);
2245 GdipDisposeImage((GpImage
*)bitmap1
);
2246 GdipDisposeImage((GpImage
*)bitmap2
);
2247 GdipDisposeImageAttributes(imageattr
);
2250 /* 1x1 pixel gif, 2 frames; first frame is white, second is black */
2251 static const unsigned char gifanimation
[72] = {
2252 0x47,0x49,0x46,0x38,0x39,0x61,0x01,0x00,0x01,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
2253 0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x21,0xf9,0x04,0x00,0x0a,0x00,0xff,
2254 0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x4c,0x01,0x00,
2255 0x21,0xf9,0x04,0x01,0x0a,0x00,0x01,0x00,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,
2256 0x00,0x00,0x02,0x02,0x44,0x01,0x00,0x3b
2259 static void test_multiframegif(void)
2271 /* Test frame functions with an animated GIF */
2272 hglob
= GlobalAlloc (0, sizeof(gifanimation
));
2273 data
= GlobalLock (hglob
);
2274 memcpy(data
, gifanimation
, sizeof(gifanimation
));
2275 GlobalUnlock(hglob
);
2277 hres
= CreateStreamOnHGlobal(hglob
, TRUE
, &stream
);
2278 ok(hres
== S_OK
, "Failed to create a stream\n");
2279 if(hres
!= S_OK
) return;
2281 stat
= GdipCreateBitmapFromStream(stream
, &bmp
);
2282 ok(stat
== Ok
, "Failed to create a Bitmap\n");
2284 IStream_Release(stream
);
2288 /* Bitmap starts at frame 0 */
2290 stat
= GdipBitmapGetPixel(bmp
, 0, 0, &color
);
2292 expect(0xffffffff, color
);
2294 /* Check that we get correct metadata */
2295 stat
= GdipImageGetFrameDimensionsCount((GpImage
*)bmp
,&count
);
2299 stat
= GdipImageGetFrameDimensionsList((GpImage
*)bmp
, &dimension
, 1);
2301 expect_guid(&FrameDimensionTime
, &dimension
, __LINE__
, FALSE
);
2304 stat
= GdipImageGetFrameCount((GpImage
*)bmp
, &dimension
, &count
);
2308 /* SelectActiveFrame overwrites our current data */
2309 stat
= GdipImageSelectActiveFrame((GpImage
*)bmp
, &dimension
, 1);
2313 GdipBitmapGetPixel(bmp
, 0, 0, &color
);
2315 expect(0xff000000, color
);
2317 stat
= GdipImageSelectActiveFrame((GpImage
*)bmp
, &dimension
, 0);
2321 GdipBitmapGetPixel(bmp
, 0, 0, &color
);
2323 expect(0xffffffff, color
);
2325 /* Write over the image data */
2326 stat
= GdipBitmapSetPixel(bmp
, 0, 0, 0xff000000);
2329 /* Switching to the same frame does not overwrite our changes */
2330 stat
= GdipImageSelectActiveFrame((GpImage
*)bmp
, &dimension
, 0);
2333 stat
= GdipBitmapGetPixel(bmp
, 0, 0, &color
);
2335 expect(0xff000000, color
);
2337 /* But switching to another frame and back does */
2338 stat
= GdipImageSelectActiveFrame((GpImage
*)bmp
, &dimension
, 1);
2341 stat
= GdipImageSelectActiveFrame((GpImage
*)bmp
, &dimension
, 0);
2344 stat
= GdipBitmapGetPixel(bmp
, 0, 0, &color
);
2346 expect(0xffffffff, color
);
2348 /* rotate/flip discards the information about other frames */
2349 stat
= GdipImageRotateFlip((GpImage
*)bmp
, Rotate90FlipNone
);
2353 stat
= GdipImageGetFrameCount((GpImage
*)bmp
, &dimension
, &count
);
2357 expect_rawformat(&ImageFormatMemoryBMP
, (GpImage
*)bmp
, __LINE__
, FALSE
);
2359 GdipDisposeImage((GpImage
*)bmp
);
2360 IStream_Release(stream
);
2362 /* Test with a non-animated gif */
2363 hglob
= GlobalAlloc (0, sizeof(gifimage
));
2364 data
= GlobalLock (hglob
);
2365 memcpy(data
, gifimage
, sizeof(gifimage
));
2366 GlobalUnlock(hglob
);
2368 hres
= CreateStreamOnHGlobal(hglob
, TRUE
, &stream
);
2369 ok(hres
== S_OK
, "Failed to create a stream\n");
2370 if(hres
!= S_OK
) return;
2372 stat
= GdipCreateBitmapFromStream(stream
, &bmp
);
2373 ok(stat
== Ok
, "Failed to create a Bitmap\n");
2375 IStream_Release(stream
);
2379 /* Check metadata */
2380 stat
= GdipImageGetFrameDimensionsCount((GpImage
*)bmp
,&count
);
2384 stat
= GdipImageGetFrameDimensionsList((GpImage
*)bmp
, &dimension
, 1);
2386 expect_guid(&FrameDimensionTime
, &dimension
, __LINE__
, FALSE
);
2389 stat
= GdipImageGetFrameCount((GpImage
*)bmp
, &dimension
, &count
);
2393 GdipDisposeImage((GpImage
*)bmp
);
2394 IStream_Release(stream
);
2397 static void test_rotateflip(void)
2402 static const BYTE orig_bits
[24] = {
2403 0,0,0xff, 0,0xff,0, 0xff,0,0, 23,23,23,
2404 0xff,0xff,0, 0xff,0,0xff, 0,0xff,0xff, 23,23,23};
2408 memcpy(bits
, orig_bits
, sizeof(bits
));
2409 stat
= GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB
, bits
, (GpBitmap
**)&bitmap
);
2412 stat
= GdipImageRotateFlip(bitmap
, Rotate90FlipNone
);
2415 stat
= GdipGetImageWidth(bitmap
, &width
);
2417 stat
= GdipGetImageHeight(bitmap
, &height
);
2422 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 0, &color
);
2424 expect(0xff00ffff, color
);
2426 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 1, 0, &color
);
2428 expect(0xffff0000, color
);
2430 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 2, &color
);
2432 expect(0xffffff00, color
);
2434 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 1, 2, &color
);
2436 expect(0xff0000ff, color
);
2440 expect(0xff, bits
[2]);
2442 GdipDisposeImage(bitmap
);
2444 memcpy(bits
, orig_bits
, sizeof(bits
));
2445 stat
= GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB
, bits
, (GpBitmap
**)&bitmap
);
2448 stat
= GdipImageRotateFlip(bitmap
, RotateNoneFlipX
);
2451 stat
= GdipGetImageWidth(bitmap
, &width
);
2453 stat
= GdipGetImageHeight(bitmap
, &height
);
2458 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 0, &color
);
2460 expect(0xff0000ff, color
);
2462 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 2, 0, &color
);
2464 expect(0xffff0000, color
);
2466 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 1, &color
);
2468 expect(0xffffff00, color
);
2470 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 2, 1, &color
);
2472 expect(0xff00ffff, color
);
2476 expect(0xff, bits
[2]);
2478 GdipDisposeImage(bitmap
);
2480 memcpy(bits
, orig_bits
, sizeof(bits
));
2481 stat
= GdipCreateBitmapFromScan0(3, 2, 12, PixelFormat24bppRGB
, bits
, (GpBitmap
**)&bitmap
);
2484 stat
= GdipImageRotateFlip(bitmap
, RotateNoneFlipY
);
2487 stat
= GdipGetImageWidth(bitmap
, &width
);
2489 stat
= GdipGetImageHeight(bitmap
, &height
);
2494 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 0, &color
);
2496 expect(0xff00ffff, color
);
2498 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 2, 0, &color
);
2500 expect(0xffffff00, color
);
2502 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 0, 1, &color
);
2504 expect(0xffff0000, color
);
2506 stat
= GdipBitmapGetPixel((GpBitmap
*)bitmap
, 2, 1, &color
);
2508 expect(0xff0000ff, color
);
2512 expect(0xff, bits
[2]);
2514 GdipDisposeImage(bitmap
);
2517 static void test_remaptable(void)
2520 GpImageAttributes
*imageattr
;
2521 GpBitmap
*bitmap1
, *bitmap2
;
2522 GpGraphics
*graphics
;
2526 map
= GdipAlloc(sizeof(ColorMap
));
2528 map
->oldColor
.Argb
= 0xff00ff00;
2529 map
->newColor
.Argb
= 0xffff00ff;
2531 stat
= GdipSetImageAttributesRemapTable(NULL
, ColorAdjustTypeDefault
, TRUE
, 1, map
);
2532 expect(InvalidParameter
, stat
);
2534 stat
= GdipCreateImageAttributes(&imageattr
);
2537 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeDefault
, TRUE
, 1, NULL
);
2538 expect(InvalidParameter
, stat
);
2540 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeCount
, TRUE
, 1, map
);
2541 expect(InvalidParameter
, stat
);
2543 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeAny
, TRUE
, 1, map
);
2544 expect(InvalidParameter
, stat
);
2546 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeDefault
, TRUE
, 0, map
);
2547 expect(InvalidParameter
, stat
);
2549 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeDefault
, FALSE
, 0, NULL
);
2552 stat
= GdipSetImageAttributesRemapTable(imageattr
, ColorAdjustTypeDefault
, TRUE
, 1, map
);
2555 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB
, NULL
, &bitmap1
);
2558 stat
= GdipCreateBitmapFromScan0(1, 1, 0, PixelFormat32bppRGB
, NULL
, &bitmap2
);
2561 stat
= GdipBitmapSetPixel(bitmap1
, 0, 0, 0xff00ff00);
2564 stat
= GdipGetImageGraphicsContext((GpImage
*)bitmap2
, &graphics
);
2567 stat
= GdipDrawImageRectRectI(graphics
, (GpImage
*)bitmap1
, 0,0,1,1, 0,0,1,1,
2568 UnitPixel
, imageattr
, NULL
, NULL
);
2571 stat
= GdipBitmapGetPixel(bitmap2
, 0, 0, &color
);
2573 ok(color_match(0xffff00ff, color
, 1), "Expected ffff00ff, got %.8x\n", color
);
2575 GdipDeleteGraphics(graphics
);
2576 GdipDisposeImage((GpImage
*)bitmap1
);
2577 GdipDisposeImage((GpImage
*)bitmap2
);
2578 GdipDisposeImageAttributes(imageattr
);
2582 static void test_colorkey(void)
2585 GpImageAttributes
*imageattr
;
2586 GpBitmap
*bitmap1
, *bitmap2
;
2587 GpGraphics
*graphics
;
2590 stat
= GdipSetImageAttributesColorKeys(NULL
, ColorAdjustTypeDefault
, TRUE
, 0xff405060, 0xff708090);
2591 expect(InvalidParameter
, stat
);
2593 stat
= GdipCreateImageAttributes(&imageattr
);
2596 stat
= GdipSetImageAttributesColorKeys(imageattr
, ColorAdjustTypeCount
, TRUE
, 0xff405060, 0xff708090);
2597 expect(InvalidParameter
, stat
);
2599 stat
= GdipSetImageAttributesColorKeys(imageattr
, ColorAdjustTypeAny
, TRUE
, 0xff405060, 0xff708090);
2600 expect(InvalidParameter
, stat
);
2602 stat
= GdipSetImageAttributesColorKeys(imageattr
, ColorAdjustTypeDefault
, TRUE
, 0xff405060, 0xff708090);
2605 stat
= GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB
, NULL
, &bitmap1
);
2608 stat
= GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB
, NULL
, &bitmap2
);
2611 stat
= GdipBitmapSetPixel(bitmap1
, 0, 0, 0x20405060);
2614 stat
= GdipBitmapSetPixel(bitmap1
, 0, 1, 0x40506070);
2617 stat
= GdipBitmapSetPixel(bitmap1
, 1, 0, 0x60708090);
2620 stat
= GdipBitmapSetPixel(bitmap1
, 1, 1, 0xffffffff);
2623 stat
= GdipGetImageGraphicsContext((GpImage
*)bitmap2
, &graphics
);
2626 stat
= GdipDrawImageRectRectI(graphics
, (GpImage
*)bitmap1
, 0,0,2,2, 0,0,2,2,
2627 UnitPixel
, imageattr
, NULL
, NULL
);
2630 stat
= GdipBitmapGetPixel(bitmap2
, 0, 0, &color
);
2632 ok(color_match(0x00000000, color
, 1), "Expected ffff00ff, got %.8x\n", color
);
2634 stat
= GdipBitmapGetPixel(bitmap2
, 0, 1, &color
);
2636 ok(color_match(0x00000000, color
, 1), "Expected ffff00ff, got %.8x\n", color
);
2638 stat
= GdipBitmapGetPixel(bitmap2
, 1, 0, &color
);
2640 ok(color_match(0x00000000, color
, 1), "Expected ffff00ff, got %.8x\n", color
);
2642 stat
= GdipBitmapGetPixel(bitmap2
, 1, 1, &color
);
2644 ok(color_match(0xffffffff, color
, 1), "Expected ffff00ff, got %.8x\n", color
);
2646 GdipDeleteGraphics(graphics
);
2647 GdipDisposeImage((GpImage
*)bitmap1
);
2648 GdipDisposeImage((GpImage
*)bitmap2
);
2649 GdipDisposeImageAttributes(imageattr
);
2652 static void test_dispose(void)
2656 char invalid_image
[256];
2658 stat
= GdipDisposeImage(NULL
);
2659 expect(InvalidParameter
, stat
);
2661 stat
= GdipCreateBitmapFromScan0(2, 2, 0, PixelFormat32bppARGB
, NULL
, (GpBitmap
**)&image
);
2664 stat
= GdipDisposeImage(image
);
2667 stat
= GdipDisposeImage(image
);
2668 expect(ObjectBusy
, stat
);
2670 memset(invalid_image
, 0, 256);
2671 stat
= GdipDisposeImage((GpImage
*)invalid_image
);
2672 expect(ObjectBusy
, stat
);
2675 static LONG
obj_refcount(void *obj
)
2677 IUnknown_AddRef((IUnknown
*)obj
);
2678 return IUnknown_Release((IUnknown
*)obj
);
2681 static GpImage
*load_image(const BYTE
*image_data
, UINT image_size
)
2688 GpImage
*image
= NULL
, *clone
;
2689 ImageType image_type
;
2690 LONG refcount
, old_refcount
;
2692 hmem
= GlobalAlloc(0, image_size
);
2693 data
= GlobalLock(hmem
);
2694 memcpy(data
, image_data
, image_size
);
2697 hr
= CreateStreamOnHGlobal(hmem
, TRUE
, &stream
);
2698 ok(hr
== S_OK
, "CreateStreamOnHGlobal error %#x\n", hr
);
2699 if (hr
!= S_OK
) return NULL
;
2701 refcount
= obj_refcount(stream
);
2702 ok(refcount
== 1, "expected stream refcount 1, got %d\n", refcount
);
2704 status
= GdipLoadImageFromStream(stream
, &image
);
2705 ok(status
== Ok
, "GdipLoadImageFromStream error %d\n", status
);
2707 status
= GdipGetImageType(image
, &image_type
);
2708 ok(status
== Ok
, "GdipGetImageType error %d\n", status
);
2710 refcount
= obj_refcount(stream
);
2711 if (image_type
== ImageTypeBitmap
)
2712 ok(refcount
> 1, "expected stream refcount > 1, got %d\n", refcount
);
2714 ok(refcount
== 1, "expected stream refcount 1, got %d\n", refcount
);
2715 old_refcount
= refcount
;
2717 status
= GdipCloneImage(image
, &clone
);
2718 ok(status
== Ok
, "GdipCloneImage error %d\n", status
);
2719 refcount
= obj_refcount(stream
);
2720 ok(refcount
== old_refcount
, "expected stream refcount %d, got %d\n", old_refcount
, refcount
);
2721 status
= GdipDisposeImage(clone
);
2722 ok(status
== Ok
, "GdipDisposeImage error %d\n", status
);
2723 refcount
= obj_refcount(stream
);
2724 ok(refcount
== old_refcount
, "expected stream refcount %d, got %d\n", old_refcount
, refcount
);
2726 refcount
= IStream_Release(stream
);
2727 if (image_type
== ImageTypeBitmap
)
2728 ok(refcount
>= 1, "expected stream refcount != 0\n");
2730 ok(refcount
== 0, "expected stream refcount 0, got %d\n", refcount
);
2735 static void test_image_properties(void)
2737 static const struct test_data
2739 const BYTE
*image_data
;
2741 ImageType image_type
;
2743 UINT prop_count2
; /* if win7 behaves differently */
2744 /* 1st property attributes */
2746 UINT prop_size2
; /* if win7 behaves differently */
2748 UINT prop_id2
; /* if win7 behaves differently */
2752 { pngimage
, sizeof(pngimage
), ImageTypeBitmap
, 4, ~0, 1, 20, 0x5110, 0x132 },
2753 { gifimage
, sizeof(gifimage
), ImageTypeBitmap
, 1, 4, 4, 0, 0x5100, 0 },
2754 { jpgimage
, sizeof(jpgimage
), ImageTypeBitmap
, 2, ~0, 128, 0, 0x5090, 0x5091 },
2755 { tiffimage
, sizeof(tiffimage
), ImageTypeBitmap
, 16, 0, 4, 0, 0xfe, 0 },
2756 { bmpimage
, sizeof(bmpimage
), ImageTypeBitmap
, 0, 0, 0, 0, 0, 0 },
2757 { wmfimage
, sizeof(wmfimage
), ImageTypeMetafile
, 0, 0, 0, 0, 0, 0 }
2761 UINT prop_count
, prop_size
, i
;
2762 PROPID prop_id
[16] = { 0 };
2763 ImageType image_type
;
2770 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
2772 image
= load_image(td
[i
].image_data
, td
[i
].image_size
);
2773 ok(image
!= 0, "%u: failed to load image data\n", i
);
2774 if (!image
) continue;
2776 status
= GdipGetImageType(image
, &image_type
);
2777 ok(status
== Ok
, "%u: GdipGetImageType error %d\n", i
, status
);
2778 ok(td
[i
].image_type
== image_type
, "%u: expected image_type %d, got %d\n",
2779 i
, td
[i
].image_type
, image_type
);
2781 status
= GdipGetPropertyCount(image
, &prop_count
);
2782 ok(status
== Ok
, "%u: GdipGetPropertyCount error %d\n", i
, status
);
2783 if (td
[i
].image_data
== pngimage
|| td
[i
].image_data
== gifimage
||
2784 td
[i
].image_data
== jpgimage
)
2786 ok(td
[i
].prop_count
== prop_count
|| td
[i
].prop_count2
== prop_count
,
2787 " %u: expected property count %u or %u, got %u\n",
2788 i
, td
[i
].prop_count
, td
[i
].prop_count2
, prop_count
);
2790 ok(td
[i
].prop_count
== prop_count
|| td
[i
].prop_count2
== prop_count
,
2791 " %u: expected property count %u or %u, got %u\n",
2792 i
, td
[i
].prop_count
, td
[i
].prop_count2
, prop_count
);
2794 status
= GdipGetPropertyItemSize(NULL
, 0, &prop_size
);
2795 expect(InvalidParameter
, status
);
2796 status
= GdipGetPropertyItemSize(image
, 0, NULL
);
2797 expect(InvalidParameter
, status
);
2798 status
= GdipGetPropertyItemSize(image
, 0, &prop_size
);
2799 if (image_type
== ImageTypeMetafile
)
2800 expect(NotImplemented
, status
);
2802 expect(PropertyNotFound
, status
);
2804 status
= GdipGetPropertyItem(NULL
, 0, 0, &item
.data
);
2805 expect(InvalidParameter
, status
);
2806 status
= GdipGetPropertyItem(image
, 0, 0, NULL
);
2807 expect(InvalidParameter
, status
);
2808 status
= GdipGetPropertyItem(image
, 0, 0, &item
.data
);
2809 if (image_type
== ImageTypeMetafile
)
2810 expect(NotImplemented
, status
);
2812 expect(PropertyNotFound
, status
);
2814 /* FIXME: remove once Wine is fixed */
2815 if (td
[i
].prop_count
!= prop_count
)
2817 GdipDisposeImage(image
);
2821 status
= GdipGetPropertyIdList(NULL
, prop_count
, prop_id
);
2822 expect(InvalidParameter
, status
);
2823 status
= GdipGetPropertyIdList(image
, prop_count
, NULL
);
2824 expect(InvalidParameter
, status
);
2825 status
= GdipGetPropertyIdList(image
, 0, prop_id
);
2826 if (image_type
== ImageTypeMetafile
)
2827 expect(NotImplemented
, status
);
2828 else if (prop_count
== 0)
2831 expect(InvalidParameter
, status
);
2832 status
= GdipGetPropertyIdList(image
, prop_count
- 1, prop_id
);
2833 if (image_type
== ImageTypeMetafile
)
2834 expect(NotImplemented
, status
);
2836 expect(InvalidParameter
, status
);
2837 status
= GdipGetPropertyIdList(image
, prop_count
+ 1, prop_id
);
2838 if (image_type
== ImageTypeMetafile
)
2839 expect(NotImplemented
, status
);
2841 expect(InvalidParameter
, status
);
2842 status
= GdipGetPropertyIdList(image
, prop_count
, prop_id
);
2843 if (image_type
== ImageTypeMetafile
)
2844 expect(NotImplemented
, status
);
2848 if (prop_count
!= 0)
2849 ok(td
[i
].prop_id
== prop_id
[0] || td
[i
].prop_id2
== prop_id
[0],
2850 " %u: expected property id %#x or %#x, got %#x\n",
2851 i
, td
[i
].prop_id
, td
[i
].prop_id2
, prop_id
[0]);
2856 status
= GdipGetPropertyItemSize(image
, prop_id
[0], &prop_size
);
2857 if (prop_count
== 0)
2858 expect(PropertyNotFound
, status
);
2863 assert(sizeof(item
) >= prop_size
);
2864 ok(prop_size
> sizeof(PropertyItem
), "%u: got too small prop_size %u\n",
2866 ok(td
[i
].prop_size
+ sizeof(PropertyItem
) == prop_size
||
2867 td
[i
].prop_size2
+ sizeof(PropertyItem
) == prop_size
,
2868 " %u: expected property size %u or %u, got %u\n",
2869 i
, td
[i
].prop_size
, td
[i
].prop_size2
, prop_size
);
2871 status
= GdipGetPropertyItem(image
, prop_id
[0], 0, &item
.data
);
2872 ok(status
== InvalidParameter
|| status
== GenericError
/* Win7 */,
2873 "%u: expected InvalidParameter, got %d\n", i
, status
);
2874 status
= GdipGetPropertyItem(image
, prop_id
[0], prop_size
- 1, &item
.data
);
2875 ok(status
== InvalidParameter
|| status
== GenericError
/* Win7 */,
2876 "%u: expected InvalidParameter, got %d\n", i
, status
);
2877 status
= GdipGetPropertyItem(image
, prop_id
[0], prop_size
+ 1, &item
.data
);
2878 ok(status
== InvalidParameter
|| status
== GenericError
/* Win7 */,
2879 "%u: expected InvalidParameter, got %d\n", i
, status
);
2880 status
= GdipGetPropertyItem(image
, prop_id
[0], prop_size
, &item
.data
);
2882 ok(prop_id
[0] == item
.data
.id
,
2883 "%u: expected property id %#x, got %#x\n", i
, prop_id
[0], item
.data
.id
);
2887 GdipDisposeImage(image
);
2895 #define IFD_RATIONAL 5
2897 #define IFD_UNDEFINED 7
2898 #define IFD_SSHORT 8
2900 #define IFD_SRATIONAL 10
2901 #define IFD_FLOAT 11
2902 #define IFD_DOUBLE 12
2904 #ifndef PropertyTagTypeSByte
2905 #define PropertyTagTypeSByte 6
2906 #define PropertyTagTypeSShort 8
2907 #define PropertyTagTypeFloat 11
2908 #define PropertyTagTypeDouble 12
2911 static UINT
documented_type(UINT type
)
2915 case PropertyTagTypeSByte
: return PropertyTagTypeByte
;
2916 case PropertyTagTypeSShort
: return PropertyTagTypeShort
;
2917 case PropertyTagTypeFloat
: return PropertyTagTypeUndefined
;
2918 case PropertyTagTypeDouble
: return PropertyTagTypeUndefined
;
2919 default: return type
;
2923 #include "pshpack2.h"
2938 static const struct tiff_data
2943 USHORT number_of_entries
;
2944 struct IFD_entry entry
[40];
2946 struct IFD_rational xres
;
2948 struct IFD_rational srational_val
;
2953 struct IFD_rational rational
[3];
2957 #ifdef WORDS_BIGENDIAN
2963 FIELD_OFFSET(struct tiff_data
, number_of_entries
),
2966 { 0xff, IFD_SHORT
, 1, 0 }, /* SUBFILETYPE */
2967 { 0x100, IFD_LONG
, 1, 1 }, /* IMAGEWIDTH */
2968 { 0x101, IFD_LONG
, 1, 1 }, /* IMAGELENGTH */
2969 { 0x102, IFD_SHORT
, 1, 1 }, /* BITSPERSAMPLE */
2970 { 0x103, IFD_LONG
, 1, 1 }, /* COMPRESSION */
2971 { 0x106, IFD_SHORT
, 1, 1 }, /* PHOTOMETRIC */
2972 { 0x111, IFD_LONG
, 1, FIELD_OFFSET(struct tiff_data
, pixel_data
) }, /* STRIPOFFSETS */
2973 { 0x115, IFD_SHORT
, 1, 1 }, /* SAMPLESPERPIXEL */
2974 { 0x116, IFD_LONG
, 1, 1 }, /* ROWSPERSTRIP */
2975 { 0x117, IFD_LONG
, 1, 1 }, /* STRIPBYTECOUNT */
2976 { 0x11a, IFD_RATIONAL
, 1, FIELD_OFFSET(struct tiff_data
, xres
) },
2977 { 0x11b, IFD_RATIONAL
, 1, FIELD_OFFSET(struct tiff_data
, xres
) },
2978 { 0x128, IFD_SHORT
, 1, 2 }, /* RESOLUTIONUNIT */
2979 { 0xf001, IFD_BYTE
, 1, 0x11223344 },
2980 { 0xf002, IFD_BYTE
, 4, 0x11223344 },
2981 { 0xf003, IFD_SBYTE
, 1, 0x11223344 },
2982 { 0xf004, IFD_SSHORT
, 1, 0x11223344 },
2983 { 0xf005, IFD_SSHORT
, 2, 0x11223344 },
2984 { 0xf006, IFD_SLONG
, 1, 0x11223344 },
2985 { 0xf007, IFD_FLOAT
, 1, 0x11223344 },
2986 { 0xf008, IFD_DOUBLE
, 1, FIELD_OFFSET(struct tiff_data
, double_val
) },
2987 { 0xf009, IFD_SRATIONAL
, 1, FIELD_OFFSET(struct tiff_data
, srational_val
) },
2988 { 0xf00a, IFD_BYTE
, 13, FIELD_OFFSET(struct tiff_data
, string
) },
2989 { 0xf00b, IFD_SSHORT
, 4, FIELD_OFFSET(struct tiff_data
, short_val
) },
2990 { 0xf00c, IFD_SLONG
, 2, FIELD_OFFSET(struct tiff_data
, long_val
) },
2991 { 0xf00e, IFD_ASCII
, 13, FIELD_OFFSET(struct tiff_data
, string
) },
2992 { 0xf00f, IFD_ASCII
, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
2993 { 0xf010, IFD_UNDEFINED
, 13, FIELD_OFFSET(struct tiff_data
, string
) },
2994 { 0xf011, IFD_UNDEFINED
, 4, 'a' | 'b' << 8 | 'c' << 16 | 'd' << 24 },
2995 /* Some gdiplus versions ignore these fields.
2996 { 0xf012, IFD_BYTE, 0, 0x11223344 },
2997 { 0xf013, IFD_SHORT, 0, 0x11223344 },
2998 { 0xf014, IFD_LONG, 0, 0x11223344 },
2999 { 0xf015, IFD_FLOAT, 0, 0x11223344 },*/
3000 { 0xf016, IFD_SRATIONAL
, 3, FIELD_OFFSET(struct tiff_data
, rational
) },
3001 /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3002 { 0xf017, IFD_FLOAT
, 2, FIELD_OFFSET(struct tiff_data
, float_val
) },
3006 1234567890.0987654321,
3007 { 0x1a2b3c4d, 0x5a6b7c8d },
3009 { 0x0101, 0x0202, 0x0303, 0x0404 },
3010 { 0x11223344, 0x55667788 },
3011 { (FLOAT
)1234.5678, (FLOAT
)8765.4321 },
3012 { { 0x01020304, 0x05060708 }, { 0x10203040, 0x50607080 }, { 0x11223344, 0x55667788 } },
3013 { 0x11, 0x22, 0x33, 0 }
3015 #include "poppack.h"
3017 static void test_tiff_properties(void)
3019 static const struct test_data
3021 ULONG type
, id
, length
;
3022 const BYTE value
[24];
3025 { PropertyTagTypeShort
, 0xff, 2, { 0 } },
3026 { PropertyTagTypeLong
, 0x100, 4, { 1 } },
3027 { PropertyTagTypeLong
, 0x101, 4, { 1 } },
3028 { PropertyTagTypeShort
, 0x102, 2, { 1 } },
3029 { PropertyTagTypeLong
, 0x103, 4, { 1 } },
3030 { PropertyTagTypeShort
, 0x106, 2, { 1 } },
3031 { PropertyTagTypeLong
, 0x111, 4, { 0x44,0x02 } },
3032 { PropertyTagTypeShort
, 0x115, 2, { 1 } },
3033 { PropertyTagTypeLong
, 0x116, 4, { 1 } },
3034 { PropertyTagTypeLong
, 0x117, 4, { 1 } },
3035 { PropertyTagTypeRational
, 0x11a, 8, { 0x84,0x03,0,0,0x03 } },
3036 { PropertyTagTypeRational
, 0x11b, 8, { 0x84,0x03,0,0,0x03 } },
3037 { PropertyTagTypeShort
, 0x128, 2, { 2 } },
3038 { PropertyTagTypeByte
, 0xf001, 1, { 0x44 } },
3039 { PropertyTagTypeByte
, 0xf002, 4, { 0x44,0x33,0x22,0x11 } },
3040 { PropertyTagTypeSByte
, 0xf003, 1, { 0x44 } },
3041 { PropertyTagTypeSShort
, 0xf004, 2, { 0x44,0x33 } },
3042 { PropertyTagTypeSShort
, 0xf005, 4, { 0x44,0x33,0x22,0x11 } },
3043 { PropertyTagTypeSLONG
, 0xf006, 4, { 0x44,0x33,0x22,0x11 } },
3044 { PropertyTagTypeFloat
, 0xf007, 4, { 0x44,0x33,0x22,0x11 } },
3045 { PropertyTagTypeDouble
, 0xf008, 8, { 0x2c,0x52,0x86,0xb4,0x80,0x65,0xd2,0x41 } },
3046 { PropertyTagTypeSRational
, 0xf009, 8, { 0x4d, 0x3c, 0x2b, 0x1a, 0x8d, 0x7c, 0x6b, 0x5a } },
3047 { PropertyTagTypeByte
, 0xf00a, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3048 { PropertyTagTypeSShort
, 0xf00b, 8, { 0x01,0x01,0x02,0x02,0x03,0x03,0x04,0x04 } },
3049 { PropertyTagTypeSLONG
, 0xf00c, 8, { 0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3050 { PropertyTagTypeASCII
, 0xf00e, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3051 { PropertyTagTypeASCII
, 0xf00f, 5, { 'a','b','c','d' } },
3052 { PropertyTagTypeUndefined
, 0xf010, 13, { 'H','e','l','l','o',' ','W','o','r','l','d','!',0 } },
3053 { PropertyTagTypeUndefined
, 0xf011, 4, { 'a','b','c','d' } },
3054 { PropertyTagTypeSRational
, 0xf016, 24,
3055 { 0x04,0x03,0x02,0x01,0x08,0x07,0x06,0x05,
3056 0x40,0x30,0x20,0x10,0x80,0x70,0x60,0x50,
3057 0x44,0x33,0x22,0x11,0x88,0x77,0x66,0x55 } },
3058 /* Win7 before SP1 doesn't recognize this field, everybody else does. */
3059 { PropertyTagTypeFloat
, 0xf017, 8, { 0x2b,0x52,0x9a,0x44,0xba,0xf5,0x08,0x46 } },
3064 UINT dim_count
, frame_count
, prop_count
, prop_size
, i
;
3066 PropertyItem
*prop_item
;
3068 image
= load_image((const BYTE
*)&TIFF_data
, sizeof(TIFF_data
));
3069 ok(image
!= 0, "Failed to load TIFF image data\n");
3072 status
= GdipImageGetFrameDimensionsCount(image
, &dim_count
);
3074 expect(1, dim_count
);
3076 status
= GdipImageGetFrameDimensionsList(image
, &guid
, 1);
3078 expect_guid(&FrameDimensionPage
, &guid
, __LINE__
, FALSE
);
3080 frame_count
= 0xdeadbeef;
3081 status
= GdipImageGetFrameCount(image
, &guid
, &frame_count
);
3083 expect(1, frame_count
);
3085 prop_count
= 0xdeadbeef;
3086 status
= GdipGetPropertyCount(image
, &prop_count
);
3088 ok(prop_count
== sizeof(td
)/sizeof(td
[0]) ||
3089 broken(prop_count
== sizeof(td
)/sizeof(td
[0]) - 1) /* Win7 SP0 */,
3090 "expected property count %u, got %u\n", (UINT
)(sizeof(td
)/sizeof(td
[0])), prop_count
);
3092 prop_id
= HeapAlloc(GetProcessHeap(), 0, prop_count
* sizeof(*prop_id
));
3094 status
= GdipGetPropertyIdList(image
, prop_count
, prop_id
);
3097 for (i
= 0; i
< prop_count
; i
++)
3099 status
= GdipGetPropertyItemSize(image
, prop_id
[i
], &prop_size
);
3101 if (status
!= Ok
) break;
3102 ok(prop_size
> sizeof(*prop_item
), "%u: too small item length %u\n", i
, prop_size
);
3104 prop_item
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, prop_size
);
3105 status
= GdipGetPropertyItem(image
, prop_id
[i
], prop_size
, prop_item
);
3107 ok(prop_item
->value
== prop_item
+ 1, "expected item->value %p, got %p\n", prop_item
+ 1, prop_item
->value
);
3108 ok(td
[i
].type
== prop_item
->type
||
3109 /* Win7 stopped using proper but not documented types, and it
3110 looks broken since TypeFloat and TypeDouble now reported as
3111 TypeUndefined, and signed types reported as unsigned. */
3112 broken(prop_item
->type
== documented_type(td
[i
].type
)),
3113 "%u: expected type %u, got %u\n", i
, td
[i
].type
, prop_item
->type
);
3114 ok(td
[i
].id
== prop_item
->id
, "%u: expected id %#x, got %#x\n", i
, td
[i
].id
, prop_item
->id
);
3115 prop_size
-= sizeof(*prop_item
);
3116 ok(prop_item
->length
== prop_size
, "%u: expected length %u, got %u\n", i
, prop_size
, prop_item
->length
);
3117 ok(td
[i
].length
== prop_item
->length
, "%u: expected length %u, got %u\n", i
, td
[i
].length
, prop_item
->length
);
3118 ok(td
[i
].length
== prop_size
, "%u: expected length %u, got %u\n", i
, td
[i
].length
, prop_size
);
3119 if (td
[i
].length
== prop_item
->length
)
3121 int match
= memcmp(td
[i
].value
, prop_item
->value
, td
[i
].length
) == 0;
3122 ok(match
|| broken(td
[i
].length
<= 4 && !match
), "%u: data mismatch\n", i
);
3126 BYTE
*data
= prop_item
->value
;
3127 printf("id %#x:", prop_item
->id
);
3128 for (j
= 0; j
< prop_item
->length
; j
++)
3129 printf(" %02x", data
[j
]);
3133 HeapFree(GetProcessHeap(), 0, prop_item
);
3136 HeapFree(GetProcessHeap(), 0, prop_id
);
3138 GdipDisposeImage(image
);
3141 static void test_GdipGetAllPropertyItems(void)
3143 static const struct test_data
3145 ULONG type
, id
, length
;
3149 { PropertyTagTypeLong
, 0xfe, 4, { 0 } },
3150 { PropertyTagTypeShort
, 0x100, 2, { 1 } },
3151 { PropertyTagTypeShort
, 0x101, 2, { 1 } },
3152 { PropertyTagTypeShort
, 0x102, 6, { 8,0,8,0,8,0 } },
3153 { PropertyTagTypeShort
, 0x103, 2, { 1 } },
3154 { PropertyTagTypeShort
, 0x106, 2, { 2,0 } },
3155 { PropertyTagTypeASCII
, 0x10d, 27, "/home/meh/Desktop/test.tif" },
3156 { PropertyTagTypeLong
, 0x111, 4, { 8,0,0,0 } },
3157 { PropertyTagTypeShort
, 0x112, 2, { 1 } },
3158 { PropertyTagTypeShort
, 0x115, 2, { 3,0 } },
3159 { PropertyTagTypeShort
, 0x116, 2, { 0x40,0 } },
3160 { PropertyTagTypeLong
, 0x117, 4, { 3,0,0,0 } },
3161 { PropertyTagTypeRational
, 0x11a, 8, { 0,0,0,72,0,0,0,1 } },
3162 { PropertyTagTypeRational
, 0x11b, 8, { 0,0,0,72,0,0,0,1 } },
3163 { PropertyTagTypeShort
, 0x11c, 2, { 1 } },
3164 { PropertyTagTypeShort
, 0x128, 2, { 2 } }
3169 UINT dim_count
, frame_count
, prop_count
, prop_size
, i
;
3170 UINT total_size
, total_count
;
3172 PropertyItem
*prop_item
;
3173 const char *item_data
;
3175 image
= load_image(tiffimage
, sizeof(tiffimage
));
3176 ok(image
!= 0, "Failed to load TIFF image data\n");
3179 dim_count
= 0xdeadbeef;
3180 status
= GdipImageGetFrameDimensionsCount(image
, &dim_count
);
3182 expect(1, dim_count
);
3184 status
= GdipImageGetFrameDimensionsList(image
, &guid
, 1);
3186 expect_guid(&FrameDimensionPage
, &guid
, __LINE__
, FALSE
);
3188 frame_count
= 0xdeadbeef;
3189 status
= GdipImageGetFrameCount(image
, &guid
, &frame_count
);
3191 expect(1, frame_count
);
3193 prop_count
= 0xdeadbeef;
3194 status
= GdipGetPropertyCount(image
, &prop_count
);
3196 ok(prop_count
== sizeof(td
)/sizeof(td
[0]),
3197 "expected property count %u, got %u\n", (UINT
)(sizeof(td
)/sizeof(td
[0])), prop_count
);
3199 prop_id
= HeapAlloc(GetProcessHeap(), 0, prop_count
* sizeof(*prop_id
));
3201 status
= GdipGetPropertyIdList(image
, prop_count
, prop_id
);
3205 for (i
= 0; i
< prop_count
; i
++)
3208 status
= GdipGetPropertyItemSize(image
, prop_id
[i
], &size
);
3210 if (status
!= Ok
) break;
3211 ok(size
> sizeof(*prop_item
), "%u: too small item length %u\n", i
, size
);
3215 prop_item
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
3216 status
= GdipGetPropertyItem(image
, prop_id
[i
], size
, prop_item
);
3218 ok(prop_item
->value
== prop_item
+ 1, "expected item->value %p, got %p\n", prop_item
+ 1, prop_item
->value
);
3219 ok(td
[i
].type
== prop_item
->type
,
3220 "%u: expected type %u, got %u\n", i
, td
[i
].type
, prop_item
->type
);
3221 ok(td
[i
].id
== prop_item
->id
, "%u: expected id %#x, got %#x\n", i
, td
[i
].id
, prop_item
->id
);
3222 size
-= sizeof(*prop_item
);
3223 ok(prop_item
->length
== size
, "%u: expected length %u, got %u\n", i
, size
, prop_item
->length
);
3224 ok(td
[i
].length
== prop_item
->length
, "%u: expected length %u, got %u\n", i
, td
[i
].length
, prop_item
->length
);
3225 if (td
[i
].length
== prop_item
->length
)
3227 int match
= memcmp(td
[i
].value
, prop_item
->value
, td
[i
].length
) == 0;
3228 ok(match
, "%u: data mismatch\n", i
);
3232 BYTE
*data
= prop_item
->value
;
3233 printf("id %#x:", prop_item
->id
);
3234 for (j
= 0; j
< prop_item
->length
; j
++)
3235 printf(" %02x", data
[j
]);
3239 HeapFree(GetProcessHeap(), 0, prop_item
);
3242 HeapFree(GetProcessHeap(), 0, prop_id
);
3244 status
= GdipGetPropertySize(NULL
, &total_size
, &total_count
);
3245 expect(InvalidParameter
, status
);
3246 status
= GdipGetPropertySize(image
, &total_size
, NULL
);
3247 expect(InvalidParameter
, status
);
3248 status
= GdipGetPropertySize(image
, NULL
, &total_count
);
3249 expect(InvalidParameter
, status
);
3250 status
= GdipGetPropertySize(image
, NULL
, NULL
);
3251 expect(InvalidParameter
, status
);
3252 total_size
= 0xdeadbeef;
3253 total_count
= 0xdeadbeef;
3254 status
= GdipGetPropertySize(image
, &total_size
, &total_count
);
3256 ok(prop_count
== total_count
,
3257 "expected total property count %u, got %u\n", prop_count
, total_count
);
3258 ok(prop_size
== total_size
,
3259 "expected total property size %u, got %u\n", prop_size
, total_size
);
3261 prop_item
= HeapAlloc(GetProcessHeap(), 0, prop_size
);
3263 status
= GdipGetAllPropertyItems(image
, 0, prop_count
, prop_item
);
3264 expect(InvalidParameter
, status
);
3265 status
= GdipGetAllPropertyItems(image
, prop_size
, 1, prop_item
);
3266 expect(InvalidParameter
, status
);
3267 status
= GdipGetAllPropertyItems(image
, prop_size
, prop_count
, NULL
);
3268 expect(InvalidParameter
, status
);
3269 status
= GdipGetAllPropertyItems(image
, prop_size
, prop_count
, NULL
);
3270 expect(InvalidParameter
, status
);
3271 status
= GdipGetAllPropertyItems(image
, 0, 0, NULL
);
3272 expect(InvalidParameter
, status
);
3273 status
= GdipGetAllPropertyItems(image
, prop_size
+ 1, prop_count
, prop_item
);
3274 expect(InvalidParameter
, status
);
3275 status
= GdipGetAllPropertyItems(image
, prop_size
, prop_count
, prop_item
);
3278 item_data
= (const char *)(prop_item
+ prop_count
);
3279 for (i
= 0; i
< prop_count
; i
++)
3281 ok(prop_item
[i
].value
== item_data
, "%u: expected value %p, got %p\n",
3282 i
, item_data
, prop_item
[i
].value
);
3283 ok(td
[i
].type
== prop_item
[i
].type
,
3284 "%u: expected type %u, got %u\n", i
, td
[i
].type
, prop_item
[i
].type
);
3285 ok(td
[i
].id
== prop_item
[i
].id
, "%u: expected id %#x, got %#x\n", i
, td
[i
].id
, prop_item
[i
].id
);
3286 ok(td
[i
].length
== prop_item
[i
].length
, "%u: expected length %u, got %u\n", i
, td
[i
].length
, prop_item
[i
].length
);
3287 if (td
[i
].length
== prop_item
[i
].length
)
3289 int match
= memcmp(td
[i
].value
, prop_item
[i
].value
, td
[i
].length
) == 0;
3290 ok(match
, "%u: data mismatch\n", i
);
3294 BYTE
*data
= prop_item
[i
].value
;
3295 printf("id %#x:", prop_item
[i
].id
);
3296 for (j
= 0; j
< prop_item
[i
].length
; j
++)
3297 printf(" %02x", data
[j
]);
3301 item_data
+= prop_item
[i
].length
;
3304 HeapFree(GetProcessHeap(), 0, prop_item
);
3306 GdipDisposeImage(image
);
3309 static void test_tiff_palette(void)
3320 ARGB
*entries
= palette
.pal
.Entries
;
3322 /* 1bpp TIFF without palette */
3323 image
= load_image((const BYTE
*)&TIFF_data
, sizeof(TIFF_data
));
3324 ok(image
!= 0, "Failed to load TIFF image data\n");
3327 status
= GdipGetImagePixelFormat(image
, &format
);
3329 ok(format
== PixelFormat1bppIndexed
, "expected PixelFormat1bppIndexed, got %#x\n", format
);
3331 status
= GdipGetImagePaletteSize(image
, &size
);
3332 ok(status
== Ok
|| broken(status
== GenericError
), /* XP */
3333 "GdipGetImagePaletteSize error %d\n", status
);
3334 if (status
== GenericError
)
3336 GdipDisposeImage(image
);
3339 expect(sizeof(ColorPalette
) + sizeof(ARGB
), size
);
3341 status
= GdipGetImagePalette(image
, &palette
.pal
, size
);
3343 expect(0, palette
.pal
.Flags
);
3344 expect(2, palette
.pal
.Count
);
3345 if (palette
.pal
.Count
== 2)
3347 ok(entries
[0] == 0xff000000, "expected 0xff000000, got %#x\n", entries
[0]);
3348 ok(entries
[1] == 0xffffffff, "expected 0xffffffff, got %#x\n", entries
[1]);
3351 GdipDisposeImage(image
);
3354 static void test_bitmapbits(void)
3357 static const BYTE pixels_24
[48] =
3359 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3360 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3361 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3362 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0
3364 static const BYTE pixels_00
[48] =
3366 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3367 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3368 0,0,0, 0,0,0, 0,0,0, 0,0,0,
3369 0,0,0, 0,0,0, 0,0,0, 0,0,0
3371 static const BYTE pixels_24_77
[64] =
3373 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3374 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3375 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3376 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3377 0xff,0xff,0xff, 0,0,0, 0xff,0xff,0xff, 0,0,0,
3378 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3380 static const BYTE pixels_77
[64] =
3382 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3383 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3384 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3385 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3386 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3387 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3388 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3389 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3391 static const BYTE pixels_8
[16] =
3393 0x01,0,0x01,0,0x01,0,0x01,0,
3394 0x01,0,0x01,0,0x01,0,0x01,0
3396 static const BYTE pixels_8_77
[64] =
3398 0x01,0,0x01,0,0x01,0,0x01,0,
3399 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3400 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3401 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3402 0x01,0,0x01,0,0x01,0,0x01,0,
3403 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3404 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3405 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3407 static const BYTE pixels_1_77
[64] =
3409 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3410 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3411 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3412 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3413 0xaa,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3414 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3415 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77,
3416 0x77,0x77,0x77,0x77,0x77,0x77,0x77,0x77
3418 static const BYTE pixels_1
[8] = {0xaa,0,0,0,0xaa,0,0,0};
3419 static const struct test_data
3426 const BYTE
*pixels_unlocked
;
3430 { PixelFormat24bppRGB
, 24, 0xfff0, 24, 48, pixels_24
, pixels_00
},
3432 { PixelFormat24bppRGB
, 24, 0, 24, 48, pixels_24
, pixels_00
},
3433 { PixelFormat24bppRGB
, 24, ImageLockModeRead
, 24, 48, pixels_24
, pixels_00
},
3434 { PixelFormat24bppRGB
, 24, ImageLockModeWrite
, 24, 48, pixels_24
, pixels_00
},
3435 { PixelFormat24bppRGB
, 24, ImageLockModeRead
|ImageLockModeWrite
, 24, 48, pixels_24
, pixels_00
},
3436 { PixelFormat24bppRGB
, 24, ImageLockModeRead
|ImageLockModeUserInputBuf
, 32, 64, pixels_24_77
, pixels_24
},
3437 { PixelFormat24bppRGB
, 24, ImageLockModeWrite
|ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_00
},
3438 { PixelFormat24bppRGB
, 24, ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_24
},
3440 { PixelFormat8bppIndexed
, 8, 0, 8, 16, pixels_8
, pixels_24
},
3441 { PixelFormat8bppIndexed
, 8, ImageLockModeRead
, 8, 16, pixels_8
, pixels_24
},
3442 { PixelFormat8bppIndexed
, 8, ImageLockModeWrite
, 8, 16, pixels_8
, pixels_00
},
3443 { PixelFormat8bppIndexed
, 8, ImageLockModeRead
|ImageLockModeWrite
, 8, 16, pixels_8
, pixels_00
},
3444 { PixelFormat8bppIndexed
, 8, ImageLockModeRead
|ImageLockModeUserInputBuf
, 32, 64, pixels_8_77
, pixels_24
},
3445 { PixelFormat8bppIndexed
, 8, ImageLockModeWrite
|ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_00
},
3446 { PixelFormat8bppIndexed
, 8, ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_24
},
3448 { PixelFormat1bppIndexed
, 1, 0, 4, 8, pixels_1
, pixels_24
},
3449 { PixelFormat1bppIndexed
, 1, ImageLockModeRead
, 4, 8, pixels_1
, pixels_24
},
3450 { PixelFormat1bppIndexed
, 1, ImageLockModeWrite
, 4, 8, pixels_1
, pixels_00
},
3451 { PixelFormat1bppIndexed
, 1, ImageLockModeRead
|ImageLockModeWrite
, 4, 8, pixels_1
, pixels_00
},
3452 { PixelFormat1bppIndexed
, 1, ImageLockModeRead
|ImageLockModeUserInputBuf
, 32, 64, pixels_1_77
, pixels_24
},
3453 { PixelFormat1bppIndexed
, 1, ImageLockModeWrite
|ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_00
},
3454 { PixelFormat1bppIndexed
, 1, ImageLockModeUserInputBuf
, 32, 64, pixels_77
, pixels_24
},
3466 ARGB
*entries
= palette
.pal
.Entries
;
3468 for (i
= 0; i
< sizeof(td
)/sizeof(td
[0]); i
++)
3470 BYTE pixels
[sizeof(pixels_24
)];
3471 memcpy(pixels
, pixels_24
, sizeof(pixels_24
));
3472 status
= GdipCreateBitmapFromScan0(8, 2, 24, PixelFormat24bppRGB
, pixels
, &bitmap
);
3475 /* associate known palette with pixel data */
3476 palette
.pal
.Flags
= PaletteFlagsGrayScale
;
3477 palette
.pal
.Count
= 2;
3478 entries
[0] = 0xff000000;
3479 entries
[1] = 0xffffffff;
3480 status
= GdipSetImagePalette((GpImage
*)bitmap
, &palette
.pal
);
3483 memset(&data
, 0xfe, sizeof(data
));
3484 if (td
[i
].mode
& ImageLockModeUserInputBuf
)
3486 memset(buf
, 0x77, sizeof(buf
));
3490 status
= GdipBitmapLockBits(bitmap
, NULL
, td
[i
].mode
, td
[i
].format
, &data
);
3491 ok(status
== Ok
|| broken(status
== InvalidParameter
) /* XP */, "%u: GdipBitmapLockBits error %d\n", i
, status
);
3494 GdipDisposeImage((GpImage
*)bitmap
);
3497 ok(data
.Width
== 8, "%u: expected 8, got %d\n", i
, data
.Width
);
3498 ok(data
.Height
== 2, "%u: expected 2, got %d\n", i
, data
.Height
);
3499 ok(td
[i
].stride
== data
.Stride
, "%u: expected %d, got %d\n", i
, td
[i
].stride
, data
.Stride
);
3500 ok(td
[i
].format
== data
.PixelFormat
, "%u: expected %d, got %d\n", i
, td
[i
].format
, data
.PixelFormat
);
3501 ok(td
[i
].size
== data
.Height
* data
.Stride
, "%u: expected %d, got %d\n", i
, td
[i
].size
, data
.Height
* data
.Stride
);
3502 if (td
[i
].mode
& ImageLockModeUserInputBuf
)
3503 ok(data
.Scan0
== buf
, "%u: got wrong buffer\n", i
);
3504 if (td
[i
].size
== data
.Height
* data
.Stride
)
3506 UINT j
, match
, width_bytes
= (data
.Width
* td
[i
].bpp
) / 8;
3509 for (j
= 0; j
< data
.Height
; j
++)
3511 if (memcmp((const BYTE
*)data
.Scan0
+ j
* data
.Stride
, td
[i
].pixels
+ j
* data
.Stride
, width_bytes
) != 0)
3517 if ((td
[i
].mode
& (ImageLockModeRead
|ImageLockModeUserInputBuf
)) || td
[i
].format
== PixelFormat24bppRGB
)
3520 "%u: data should match\n", i
);
3523 BYTE
*bits
= data
.Scan0
;
3524 printf("%u: data mismatch for format %#x:", i
, td
[i
].format
);
3525 for (j
= 0; j
< td
[i
].size
; j
++)
3526 printf(" %02x", bits
[j
]);
3531 ok(!match
, "%u: data shouldn't match\n", i
);
3533 memset(data
.Scan0
, 0, td
[i
].size
);
3536 status
= GdipBitmapUnlockBits(bitmap
, &data
);
3537 ok(status
== Ok
, "%u: GdipBitmapUnlockBits error %d\n", i
, status
);
3539 memset(&data
, 0xfe, sizeof(data
));
3540 status
= GdipBitmapLockBits(bitmap
, NULL
, ImageLockModeRead
, PixelFormat24bppRGB
, &data
);
3541 ok(status
== Ok
, "%u: GdipBitmapLockBits error %d\n", i
, status
);
3542 ok(data
.Width
== 8, "%u: expected 8, got %d\n", i
, data
.Width
);
3543 ok(data
.Height
== 2, "%u: expected 2, got %d\n", i
, data
.Height
);
3544 ok(data
.Stride
== 24, "%u: expected 24, got %d\n", i
, data
.Stride
);
3545 ok(data
.PixelFormat
== PixelFormat24bppRGB
, "%u: got wrong pixel format %d\n", i
, data
.PixelFormat
);
3546 ok(data
.Height
* data
.Stride
== 48, "%u: expected 48, got %d\n", i
, data
.Height
* data
.Stride
);
3547 if (data
.Height
* data
.Stride
== 48)
3549 int match
= memcmp(data
.Scan0
, td
[i
].pixels_unlocked
, 48) == 0;
3550 ok(match
, "%u: data should match\n", i
);
3554 BYTE
*bits
= data
.Scan0
;
3555 printf("%u: data mismatch for format %#x:", i
, td
[i
].format
);
3556 for (j
= 0; j
< 48; j
++)
3557 printf(" %02x", bits
[j
]);
3562 status
= GdipBitmapUnlockBits(bitmap
, &data
);
3563 ok(status
== Ok
, "%u: GdipBitmapUnlockBits error %d\n", i
, status
);
3565 status
= GdipDisposeImage((GpImage
*)bitmap
);
3572 struct GdiplusStartupInput gdiplusStartupInput
;
3573 ULONG_PTR gdiplusToken
;
3575 gdiplusStartupInput
.GdiplusVersion
= 1;
3576 gdiplusStartupInput
.DebugEventCallback
= NULL
;
3577 gdiplusStartupInput
.SuppressBackgroundThread
= 0;
3578 gdiplusStartupInput
.SuppressExternalCodecs
= 0;
3580 GdiplusStartup(&gdiplusToken
, &gdiplusStartupInput
, NULL
);
3583 test_tiff_palette();
3584 test_GdipGetAllPropertyItems();
3585 test_tiff_properties();
3586 test_image_properties();
3589 test_GetImageDimension();
3590 test_GdipImageGetFrameDimensionsCount();
3591 test_LoadingImages();
3592 test_SavingImages();
3595 test_LockBits_UserBuf();
3596 test_GdipCreateBitmapFromHBITMAP();
3597 test_GdipGetImageFlags();
3598 test_GdipCloneImage();
3601 test_getrawformat();
3603 test_createfromwmf();
3605 test_createhbitmap();
3606 test_getthumbnail();
3611 test_multiframegif();
3617 GdiplusShutdown(gdiplusToken
);