?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32/tooltips: Reset window subclass data when removing tools.
[wine.git] / dlls / gdiplus / image.c
blobc0b54d04d832516d9c34794b723feeaa757854d7
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 * Copyright (C) 2012,2016 Dmitry Timoshkov
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdarg.h>
21 #include <assert.h>
22
23 #define NONAMELESSUNION
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "wingdi.h"
29
30 #define COBJMACROS
31 #include "objbase.h"
32 #include "olectl.h"
33 #include "ole2.h"
34
35 #include "initguid.h"
36 #include "wincodec.h"
37 #include "gdiplus.h"
38 #include "gdiplus_private.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
42
43 HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
44
45 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
46 #define WMF_PLACEABLE_KEY 0x9ac6cdd7
47
48 static const struct
49 {
50 const WICPixelFormatGUID *wic_format;
51 PixelFormat gdip_format;
52 /* predefined palette type to use for pixel format conversions */
53 WICBitmapPaletteType palette_type;
54 } pixel_formats[] =
55 {
56 { &GUID_WICPixelFormatBlackWhite, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
57 { &GUID_WICPixelFormat1bppIndexed, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
58 { &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
59 { &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
60 { &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, WICBitmapPaletteTypeFixedHalftone256 },
61 { &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
62 { &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
63 { &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedHalftone256 },
64 { &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, WICBitmapPaletteTypeFixedHalftone256 },
65 { NULL }
66 };
67
68 static ColorPalette *get_palette(IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)
69 {
70 HRESULT hr;
71 IWICImagingFactory *factory;
72 IWICPalette *wic_palette;
73 ColorPalette *palette = NULL;
74
75 hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
76 if (hr != S_OK) return NULL;
77
78 hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
79 if (hr == S_OK)
80 {
81 hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
82 if (frame)
83 hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
84 if (hr != S_OK)
85 {
86 TRACE("using predefined palette %#x\n", palette_type);
87 hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
88 }
89 if (hr == S_OK)
90 {
91 WICBitmapPaletteType type;
92 BOOL alpha;
93 UINT count;
94
95 IWICPalette_GetColorCount(wic_palette, &count);
96 palette = heap_alloc(2 * sizeof(UINT) + count * sizeof(ARGB));
97 IWICPalette_GetColors(wic_palette, count, palette->Entries, &palette->Count);
98
99 IWICPalette_GetType(wic_palette, &type);
100 switch(type) {
101 case WICBitmapPaletteTypeFixedGray4:
102 case WICBitmapPaletteTypeFixedGray16:
103 case WICBitmapPaletteTypeFixedGray256:
104 palette->Flags = PaletteFlagsGrayScale;
105 break;
106 case WICBitmapPaletteTypeFixedHalftone8:
107 case WICBitmapPaletteTypeFixedHalftone27:
108 case WICBitmapPaletteTypeFixedHalftone64:
109 case WICBitmapPaletteTypeFixedHalftone125:
110 case WICBitmapPaletteTypeFixedHalftone216:
111 case WICBitmapPaletteTypeFixedHalftone252:
112 case WICBitmapPaletteTypeFixedHalftone256:
113 palette->Flags = PaletteFlagsHalftone;
114 break;
115 default:
116 palette->Flags = 0;
117 }
118 IWICPalette_HasAlpha(wic_palette, &alpha);
119 if(alpha)
120 palette->Flags |= PaletteFlagsHasAlpha;
121 }
122 IWICPalette_Release(wic_palette);
123 }
124 IWICImagingFactory_Release(factory);
125 return palette;
126 }
127
128 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
129 RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
130 {
131 FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
132 /*
133 * Note: According to Jose Roca's GDI+ docs, this function is not
134 * implemented in Windows's GDI+.
135 */
136 return NotImplemented;
137 }
138
139 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
140 INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
141 GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
142 {
143 FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
144 /*
145 * Note: According to Jose Roca's GDI+ docs, this function is not
146 * implemented in Windows's GDI+.
147 */
148 return NotImplemented;
149 }
150
151 static inline void getpixel_1bppIndexed(BYTE *index, const BYTE *row, UINT x)
152 {
153 *index = (row[x/8]>>(7-x%8)) & 1;
154 }
155
156 static inline void getpixel_4bppIndexed(BYTE *index, const BYTE *row, UINT x)
157 {
158 if (x & 1)
159 *index = row[x/2]&0xf;
160 else
161 *index = row[x/2]>>4;
162 }
163
164 static inline void getpixel_8bppIndexed(BYTE *index, const BYTE *row, UINT x)
165 {
166 *index = row[x];
167 }
168
169 static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
170 const BYTE *row, UINT x)
171 {
172 *r = *g = *b = row[x*2+1];
173 *a = 255;
174 }
175
176 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
177 const BYTE *row, UINT x)
178 {
179 WORD pixel = *((const WORD*)(row)+x);
180 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
181 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
182 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
183 *a = 255;
184 }
185
186 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
187 const BYTE *row, UINT x)
188 {
189 WORD pixel = *((const WORD*)(row)+x);
190 *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
191 *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
192 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
193 *a = 255;
194 }
195
196 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
197 const BYTE *row, UINT x)
198 {
199 WORD pixel = *((const WORD*)(row)+x);
200 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
201 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
202 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
203 if ((pixel&0x8000) == 0x8000)
204 *a = 255;
205 else
206 *a = 0;
207 }
208
209 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
210 const BYTE *row, UINT x)
211 {
212 *r = row[x*3+2];
213 *g = row[x*3+1];
214 *b = row[x*3];
215 *a = 255;
216 }
217
218 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
219 const BYTE *row, UINT x)
220 {
221 *r = row[x*4+2];
222 *g = row[x*4+1];
223 *b = row[x*4];
224 *a = 255;
225 }
226
227 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
228 const BYTE *row, UINT x)
229 {
230 *r = row[x*4+2];
231 *g = row[x*4+1];
232 *b = row[x*4];
233 *a = row[x*4+3];
234 }
235
236 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
237 const BYTE *row, UINT x)
238 {
239 *a = row[x*4+3];
240 if (*a == 0)
241 *r = *g = *b = 0;
242 else
243 {
244 *r = row[x*4+2] * 255 / *a;
245 *g = row[x*4+1] * 255 / *a;
246 *b = row[x*4] * 255 / *a;
247 }
248 }
249
250 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
251 const BYTE *row, UINT x)
252 {
253 *r = row[x*6+5];
254 *g = row[x*6+3];
255 *b = row[x*6+1];
256 *a = 255;
257 }
258
259 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
260 const BYTE *row, UINT x)
261 {
262 *r = row[x*8+5];
263 *g = row[x*8+3];
264 *b = row[x*8+1];
265 *a = row[x*8+7];
266 }
267
268 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
269 const BYTE *row, UINT x)
270 {
271 *a = row[x*8+7];
272 if (*a == 0)
273 *r = *g = *b = 0;
274 else
275 {
276 *r = row[x*8+5] * 255 / *a;
277 *g = row[x*8+3] * 255 / *a;
278 *b = row[x*8+1] * 255 / *a;
279 }
280 }
281
282 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
283 ARGB *color)
284 {
285 BYTE r, g, b, a;
286 BYTE index;
287 BYTE *row;
288
289 if(!bitmap || !color ||
290 x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
291 return InvalidParameter;
292
293 row = bitmap->bits+bitmap->stride*y;
294
295 switch (bitmap->format)
296 {
297 case PixelFormat1bppIndexed:
298 getpixel_1bppIndexed(&index,row,x);
299 break;
300 case PixelFormat4bppIndexed:
301 getpixel_4bppIndexed(&index,row,x);
302 break;
303 case PixelFormat8bppIndexed:
304 getpixel_8bppIndexed(&index,row,x);
305 break;
306 case PixelFormat16bppGrayScale:
307 getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
308 break;
309 case PixelFormat16bppRGB555:
310 getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
311 break;
312 case PixelFormat16bppRGB565:
313 getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
314 break;
315 case PixelFormat16bppARGB1555:
316 getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
317 break;
318 case PixelFormat24bppRGB:
319 getpixel_24bppRGB(&r,&g,&b,&a,row,x);
320 break;
321 case PixelFormat32bppRGB:
322 getpixel_32bppRGB(&r,&g,&b,&a,row,x);
323 break;
324 case PixelFormat32bppARGB:
325 getpixel_32bppARGB(&r,&g,&b,&a,row,x);
326 break;
327 case PixelFormat32bppPARGB:
328 getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
329 break;
330 case PixelFormat48bppRGB:
331 getpixel_48bppRGB(&r,&g,&b,&a,row,x);
332 break;
333 case PixelFormat64bppARGB:
334 getpixel_64bppARGB(&r,&g,&b,&a,row,x);
335 break;
336 case PixelFormat64bppPARGB:
337 getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
338 break;
339 default:
340 FIXME("not implemented for format 0x%x\n", bitmap->format);
341 return NotImplemented;
342 }
343
344 if (bitmap->format & PixelFormatIndexed)
345 *color = bitmap->image.palette->Entries[index];
346 else
347 *color = a<<24|r<<16|g<<8|b;
348
349 return Ok;
350 }
351
352 static inline UINT get_palette_index(BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)
353 {
354 BYTE index = 0;
355 int best_distance = 0x7fff;
356 int distance;
357 UINT i;
358
359 if (!palette) return 0;
360 /* This algorithm scans entire palette,
361 computes difference from desired color (all color components have equal weight)
362 and returns the index of color with least difference.
363
364 Note: Maybe it could be replaced with a better algorithm for better image quality
365 and performance, though better algorithm would probably need some pre-built lookup
366 tables and thus may actually be slower if this method is called only few times per
367 every image.
368 */
369 for(i=0;i<palette->Count;i++) {
370 ARGB color=palette->Entries[i];
371 distance=abs(b-(color & 0xff)) + abs(g-(color>>8 & 0xff)) + abs(r-(color>>16 & 0xff)) + abs(a-(color>>24 & 0xff));
372 if (distance<best_distance) {
373 best_distance=distance;
374 index=i;
375 }
376 }
377 return index;
378 }
379
380 static inline void setpixel_8bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
381 BYTE *row, UINT x, ColorPalette *palette)
382 {
383 BYTE index = get_palette_index(r,g,b,a,palette);
384 row[x]=index;
385 }
386
387 static inline void setpixel_1bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
388 BYTE *row, UINT x, ColorPalette *palette)
389 {
390 row[x/8] = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
391 }
392
393 static inline void setpixel_4bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
394 BYTE *row, UINT x, ColorPalette *palette)
395 {
396 if (x & 1)
397 row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
398 else
399 row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
400 }
401
402 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
403 BYTE *row, UINT x)
404 {
405 *((WORD*)(row)+x) = (r+g+b)*85;
406 }
407
408 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
409 BYTE *row, UINT x)
410 {
411 *((WORD*)(row)+x) = (r<<7&0x7c00)|
412 (g<<2&0x03e0)|
413 (b>>3&0x001f);
414 }
415
416 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
417 BYTE *row, UINT x)
418 {
419 *((WORD*)(row)+x) = (r<<8&0xf800)|
420 (g<<3&0x07e0)|
421 (b>>3&0x001f);
422 }
423
424 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
425 BYTE *row, UINT x)
426 {
427 *((WORD*)(row)+x) = (a<<8&0x8000)|
428 (r<<7&0x7c00)|
429 (g<<2&0x03e0)|
430 (b>>3&0x001f);
431 }
432
433 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
434 BYTE *row, UINT x)
435 {
436 row[x*3+2] = r;
437 row[x*3+1] = g;
438 row[x*3] = b;
439 }
440
441 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
442 BYTE *row, UINT x)
443 {
444 *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
445 }
446
447 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
448 BYTE *row, UINT x)
449 {
450 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
451 }
452
453 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
454 BYTE *row, UINT x)
455 {
456 r = r * a / 255;
457 g = g * a / 255;
458 b = b * a / 255;
459 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
460 }
461
462 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
463 BYTE *row, UINT x)
464 {
465 row[x*6+5] = row[x*6+4] = r;
466 row[x*6+3] = row[x*6+2] = g;
467 row[x*6+1] = row[x*6] = b;
468 }
469
470 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
471 BYTE *row, UINT x)
472 {
473 UINT64 a64=a, r64=r, g64=g, b64=b;
474 *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
475 }
476
477 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
478 BYTE *row, UINT x)
479 {
480 UINT64 a64, r64, g64, b64;
481 a64 = a * 257;
482 r64 = r * a / 255;
483 g64 = g * a / 255;
484 b64 = b * a / 255;
485 *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
486 }
487
488 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
489 ARGB color)
490 {
491 BYTE a, r, g, b;
492 BYTE *row;
493
494 if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
495 return InvalidParameter;
496
497 a = color>>24;
498 r = color>>16;
499 g = color>>8;
500 b = color;
501
502 row = bitmap->bits + bitmap->stride * y;
503
504 switch (bitmap->format)
505 {
506 case PixelFormat16bppGrayScale:
507 setpixel_16bppGrayScale(r,g,b,a,row,x);
508 break;
509 case PixelFormat16bppRGB555:
510 setpixel_16bppRGB555(r,g,b,a,row,x);
511 break;
512 case PixelFormat16bppRGB565:
513 setpixel_16bppRGB565(r,g,b,a,row,x);
514 break;
515 case PixelFormat16bppARGB1555:
516 setpixel_16bppARGB1555(r,g,b,a,row,x);
517 break;
518 case PixelFormat24bppRGB:
519 setpixel_24bppRGB(r,g,b,a,row,x);
520 break;
521 case PixelFormat32bppRGB:
522 setpixel_32bppRGB(r,g,b,a,row,x);
523 break;
524 case PixelFormat32bppARGB:
525 setpixel_32bppARGB(r,g,b,a,row,x);
526 break;
527 case PixelFormat32bppPARGB:
528 setpixel_32bppPARGB(r,g,b,a,row,x);
529 break;
530 case PixelFormat48bppRGB:
531 setpixel_48bppRGB(r,g,b,a,row,x);
532 break;
533 case PixelFormat64bppARGB:
534 setpixel_64bppARGB(r,g,b,a,row,x);
535 break;
536 case PixelFormat64bppPARGB:
537 setpixel_64bppPARGB(r,g,b,a,row,x);
538 break;
539 case PixelFormat8bppIndexed:
540 setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
541 break;
542 case PixelFormat4bppIndexed:
543 setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
544 break;
545 case PixelFormat1bppIndexed:
546 setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
547 break;
548 default:
549 FIXME("not implemented for format 0x%x\n", bitmap->format);
550 return NotImplemented;
551 }
552
553 return Ok;
554 }
555
556 GpStatus convert_pixels(INT width, INT height,
557 INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
558 INT src_stride, const BYTE *src_bits, PixelFormat src_format,
559 ColorPalette *palette)
560 {
561 INT x, y;
562
563 if (src_format == dst_format ||
564 (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
565 {
566 UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
567 for (y=0; y<height; y++)
568 memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
569 return Ok;
570 }
571
572 #define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
573 for (y=0; y<height; y++) \
574 for (x=0; x<width; x++) { \
575 BYTE index; \
576 ARGB argb; \
577 BYTE *color = (BYTE *)&argb; \
578 getpixel_function(&index, src_bits+src_stride*y, x); \
579 argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
580 setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
581 } \
582 return Ok; \
583 } while (0);
584
585 #define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
586 for (y=0; y<height; y++) \
587 for (x=0; x<width; x++) { \
588 BYTE r, g, b, a; \
589 getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
590 setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
591 } \
592 return Ok; \
593 } while (0);
594
595 #define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
596 for (y=0; y<height; y++) \
597 for (x=0; x<width; x++) { \
598 BYTE r, g, b, a; \
599 getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
600 setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
601 } \
602 return Ok; \
603 } while (0);
604
605 switch (src_format)
606 {
607 case PixelFormat1bppIndexed:
608 switch (dst_format)
609 {
610 case PixelFormat16bppGrayScale:
611 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
612 case PixelFormat16bppRGB555:
613 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
614 case PixelFormat16bppRGB565:
615 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
616 case PixelFormat16bppARGB1555:
617 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
618 case PixelFormat24bppRGB:
619 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
620 case PixelFormat32bppRGB:
621 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
622 case PixelFormat32bppARGB:
623 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
624 case PixelFormat32bppPARGB:
625 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
626 case PixelFormat48bppRGB:
627 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
628 case PixelFormat64bppARGB:
629 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
630 default:
631 break;
632 }
633 break;
634 case PixelFormat4bppIndexed:
635 switch (dst_format)
636 {
637 case PixelFormat16bppGrayScale:
638 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
639 case PixelFormat16bppRGB555:
640 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
641 case PixelFormat16bppRGB565:
642 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
643 case PixelFormat16bppARGB1555:
644 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
645 case PixelFormat24bppRGB:
646 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
647 case PixelFormat32bppRGB:
648 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
649 case PixelFormat32bppARGB:
650 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
651 case PixelFormat32bppPARGB:
652 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
653 case PixelFormat48bppRGB:
654 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
655 case PixelFormat64bppARGB:
656 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
657 default:
658 break;
659 }
660 break;
661 case PixelFormat8bppIndexed:
662 switch (dst_format)
663 {
664 case PixelFormat16bppGrayScale:
665 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
666 case PixelFormat16bppRGB555:
667 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
668 case PixelFormat16bppRGB565:
669 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
670 case PixelFormat16bppARGB1555:
671 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
672 case PixelFormat24bppRGB:
673 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
674 case PixelFormat32bppRGB:
675 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
676 case PixelFormat32bppARGB:
677 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
678 case PixelFormat32bppPARGB:
679 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
680 case PixelFormat48bppRGB:
681 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
682 case PixelFormat64bppARGB:
683 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
684 default:
685 break;
686 }
687 break;
688 case PixelFormat16bppGrayScale:
689 switch (dst_format)
690 {
691 case PixelFormat1bppIndexed:
692 convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
693 case PixelFormat8bppIndexed:
694 convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
695 case PixelFormat16bppRGB555:
696 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
697 case PixelFormat16bppRGB565:
698 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
699 case PixelFormat16bppARGB1555:
700 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
701 case PixelFormat24bppRGB:
702 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
703 case PixelFormat32bppRGB:
704 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
705 case PixelFormat32bppARGB:
706 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
707 case PixelFormat32bppPARGB:
708 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
709 case PixelFormat48bppRGB:
710 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
711 case PixelFormat64bppARGB:
712 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
713 default:
714 break;
715 }
716 break;
717 case PixelFormat16bppRGB555:
718 switch (dst_format)
719 {
720 case PixelFormat1bppIndexed:
721 convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
722 case PixelFormat8bppIndexed:
723 convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
724 case PixelFormat16bppGrayScale:
725 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
726 case PixelFormat16bppRGB565:
727 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
728 case PixelFormat16bppARGB1555:
729 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
730 case PixelFormat24bppRGB:
731 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
732 case PixelFormat32bppRGB:
733 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
734 case PixelFormat32bppARGB:
735 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
736 case PixelFormat32bppPARGB:
737 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
738 case PixelFormat48bppRGB:
739 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
740 case PixelFormat64bppARGB:
741 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
742 default:
743 break;
744 }
745 break;
746 case PixelFormat16bppRGB565:
747 switch (dst_format)
748 {
749 case PixelFormat1bppIndexed:
750 convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
751 case PixelFormat8bppIndexed:
752 convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
753 case PixelFormat16bppGrayScale:
754 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
755 case PixelFormat16bppRGB555:
756 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
757 case PixelFormat16bppARGB1555:
758 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
759 case PixelFormat24bppRGB:
760 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
761 case PixelFormat32bppRGB:
762 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
763 case PixelFormat32bppARGB:
764 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
765 case PixelFormat32bppPARGB:
766 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
767 case PixelFormat48bppRGB:
768 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
769 case PixelFormat64bppARGB:
770 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
771 default:
772 break;
773 }
774 break;
775 case PixelFormat16bppARGB1555:
776 switch (dst_format)
777 {
778 case PixelFormat1bppIndexed:
779 convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
780 case PixelFormat8bppIndexed:
781 convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
782 case PixelFormat16bppGrayScale:
783 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
784 case PixelFormat16bppRGB555:
785 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
786 case PixelFormat16bppRGB565:
787 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
788 case PixelFormat24bppRGB:
789 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
790 case PixelFormat32bppRGB:
791 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
792 case PixelFormat32bppARGB:
793 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
794 case PixelFormat32bppPARGB:
795 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
796 case PixelFormat48bppRGB:
797 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
798 case PixelFormat64bppARGB:
799 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
800 default:
801 break;
802 }
803 break;
804 case PixelFormat24bppRGB:
805 switch (dst_format)
806 {
807 case PixelFormat1bppIndexed:
808 convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
809 case PixelFormat8bppIndexed:
810 convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
811 case PixelFormat16bppGrayScale:
812 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
813 case PixelFormat16bppRGB555:
814 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
815 case PixelFormat16bppRGB565:
816 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
817 case PixelFormat16bppARGB1555:
818 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
819 case PixelFormat32bppRGB:
820 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
821 case PixelFormat32bppARGB:
822 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
823 case PixelFormat32bppPARGB:
824 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
825 case PixelFormat48bppRGB:
826 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
827 case PixelFormat64bppARGB:
828 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
829 default:
830 break;
831 }
832 break;
833 case PixelFormat32bppRGB:
834 switch (dst_format)
835 {
836 case PixelFormat1bppIndexed:
837 convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
838 case PixelFormat8bppIndexed:
839 convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
840 case PixelFormat16bppGrayScale:
841 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
842 case PixelFormat16bppRGB555:
843 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
844 case PixelFormat16bppRGB565:
845 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
846 case PixelFormat16bppARGB1555:
847 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
848 case PixelFormat24bppRGB:
849 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
850 case PixelFormat32bppARGB:
851 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
852 case PixelFormat32bppPARGB:
853 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
854 case PixelFormat48bppRGB:
855 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
856 case PixelFormat64bppARGB:
857 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
858 default:
859 break;
860 }
861 break;
862 case PixelFormat32bppARGB:
863 switch (dst_format)
864 {
865 case PixelFormat1bppIndexed:
866 convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
867 case PixelFormat8bppIndexed:
868 convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
869 case PixelFormat16bppGrayScale:
870 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
871 case PixelFormat16bppRGB555:
872 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
873 case PixelFormat16bppRGB565:
874 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
875 case PixelFormat16bppARGB1555:
876 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
877 case PixelFormat24bppRGB:
878 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
879 case PixelFormat32bppPARGB:
880 convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
881 return Ok;
882 case PixelFormat48bppRGB:
883 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
884 case PixelFormat64bppARGB:
885 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
886 default:
887 break;
888 }
889 break;
890 case PixelFormat32bppPARGB:
891 switch (dst_format)
892 {
893 case PixelFormat1bppIndexed:
894 convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
895 case PixelFormat8bppIndexed:
896 convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
897 case PixelFormat16bppGrayScale:
898 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
899 case PixelFormat16bppRGB555:
900 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
901 case PixelFormat16bppRGB565:
902 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
903 case PixelFormat16bppARGB1555:
904 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
905 case PixelFormat24bppRGB:
906 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
907 case PixelFormat32bppRGB:
908 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
909 case PixelFormat32bppARGB:
910 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
911 case PixelFormat48bppRGB:
912 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
913 case PixelFormat64bppARGB:
914 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
915 default:
916 break;
917 }
918 break;
919 case PixelFormat48bppRGB:
920 switch (dst_format)
921 {
922 case PixelFormat1bppIndexed:
923 convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
924 case PixelFormat8bppIndexed:
925 convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
926 case PixelFormat16bppGrayScale:
927 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
928 case PixelFormat16bppRGB555:
929 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
930 case PixelFormat16bppRGB565:
931 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
932 case PixelFormat16bppARGB1555:
933 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
934 case PixelFormat24bppRGB:
935 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
936 case PixelFormat32bppRGB:
937 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
938 case PixelFormat32bppARGB:
939 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
940 case PixelFormat32bppPARGB:
941 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
942 case PixelFormat64bppARGB:
943 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
944 default:
945 break;
946 }
947 break;
948 case PixelFormat64bppARGB:
949 switch (dst_format)
950 {
951 case PixelFormat1bppIndexed:
952 convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
953 case PixelFormat8bppIndexed:
954 convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
955 case PixelFormat16bppGrayScale:
956 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
957 case PixelFormat16bppRGB555:
958 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
959 case PixelFormat16bppRGB565:
960 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
961 case PixelFormat16bppARGB1555:
962 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
963 case PixelFormat24bppRGB:
964 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
965 case PixelFormat32bppRGB:
966 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
967 case PixelFormat32bppARGB:
968 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
969 case PixelFormat32bppPARGB:
970 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
971 case PixelFormat48bppRGB:
972 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
973 default:
974 break;
975 }
976 break;
977 case PixelFormat64bppPARGB:
978 switch (dst_format)
979 {
980 case PixelFormat1bppIndexed:
981 convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
982 case PixelFormat8bppIndexed:
983 convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
984 case PixelFormat16bppGrayScale:
985 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
986 case PixelFormat16bppRGB555:
987 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
988 case PixelFormat16bppRGB565:
989 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
990 case PixelFormat16bppARGB1555:
991 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
992 case PixelFormat24bppRGB:
993 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
994 case PixelFormat32bppRGB:
995 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
996 case PixelFormat32bppARGB:
997 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
998 case PixelFormat32bppPARGB:
999 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
1000 case PixelFormat48bppRGB:
1001 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
1002 case PixelFormat64bppARGB:
1003 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
1004 default:
1005 break;
1006 }
1007 break;
1008 default:
1009 break;
1010 }
1011
1012 #undef convert_indexed_to_rgb
1013 #undef convert_rgb_to_rgb
1014
1015 return NotImplemented;
1016 }
1017
1018 /* This function returns a pointer to an array of pixels that represents the
1019 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
1020 * flags. It is correct behavior that a user who calls this function with write
1021 * privileges can write to the whole bitmap (not just the area in rect).
1022 *
1023 * FIXME: only used portion of format is bits per pixel. */
1024 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
1025 UINT flags, PixelFormat format, BitmapData* lockeddata)
1026 {
1027 INT bitspp = PIXELFORMATBPP(format);
1028 GpRect act_rect; /* actual rect to be used */
1029 GpStatus stat;
1030 BOOL unlock;
1031
1032 TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
1033
1034 if(!lockeddata || !bitmap)
1035 return InvalidParameter;
1036 if(!image_lock(&bitmap->image, &unlock))
1037 return ObjectBusy;
1038
1039 if(rect){
1040 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
1041 (rect->Y + rect->Height > bitmap->height) || !flags)
1042 {
1043 image_unlock(&bitmap->image, unlock);
1044 return InvalidParameter;
1045 }
1046
1047 act_rect = *rect;
1048 }
1049 else{
1050 act_rect.X = act_rect.Y = 0;
1051 act_rect.Width = bitmap->width;
1052 act_rect.Height = bitmap->height;
1053 }
1054
1055 if(bitmap->lockmode)
1056 {
1057 WARN("bitmap is already locked and cannot be locked again\n");
1058 image_unlock(&bitmap->image, unlock);
1059 return WrongState;
1060 }
1061
1062 if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
1063 {
1064 /* no conversion is necessary; just use the bits directly */
1065 lockeddata->Width = act_rect.Width;
1066 lockeddata->Height = act_rect.Height;
1067 lockeddata->PixelFormat = format;
1068 lockeddata->Reserved = flags;
1069 lockeddata->Stride = bitmap->stride;
1070 lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
1071 bitmap->stride * act_rect.Y;
1072
1073 bitmap->lockmode = flags | ImageLockModeRead;
1074
1075 image_unlock(&bitmap->image, unlock);
1076 return Ok;
1077 }
1078
1079 /* Make sure we can convert to the requested format. */
1080 if (flags & ImageLockModeRead)
1081 {
1082 stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
1083 if (stat == NotImplemented)
1084 {
1085 FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
1086 image_unlock(&bitmap->image, unlock);
1087 return NotImplemented;
1088 }
1089 }
1090
1091 /* If we're opening for writing, make sure we'll be able to write back in
1092 * the original format. */
1093 if (flags & ImageLockModeWrite)
1094 {
1095 stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
1096 if (stat == NotImplemented)
1097 {
1098 FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
1099 image_unlock(&bitmap->image, unlock);
1100 return NotImplemented;
1101 }
1102 }
1103
1104 lockeddata->Width = act_rect.Width;
1105 lockeddata->Height = act_rect.Height;
1106 lockeddata->PixelFormat = format;
1107 lockeddata->Reserved = flags;
1108
1109 if(!(flags & ImageLockModeUserInputBuf))
1110 {
1111 lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
1112
1113 bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
1114
1115 if (!bitmap->bitmapbits)
1116 {
1117 image_unlock(&bitmap->image, unlock);
1118 return OutOfMemory;
1119 }
1120
1121 lockeddata->Scan0 = bitmap->bitmapbits;
1122 }
1123
1124 if (flags & ImageLockModeRead)
1125 {
1126 static BOOL fixme = FALSE;
1127
1128 if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
1129 {
1130 FIXME("Cannot copy rows that don't start at a whole byte.\n");
1131 fixme = TRUE;
1132 }
1133
1134 stat = convert_pixels(act_rect.Width, act_rect.Height,
1135 lockeddata->Stride, lockeddata->Scan0, format,
1136 bitmap->stride,
1137 bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
1138 bitmap->format, bitmap->image.palette);
1139
1140 if (stat != Ok)
1141 {
1142 heap_free(bitmap->bitmapbits);
1143 bitmap->bitmapbits = NULL;
1144 image_unlock(&bitmap->image, unlock);
1145 return stat;
1146 }
1147 }
1148
1149 bitmap->lockmode = flags | ImageLockModeRead;
1150 bitmap->lockx = act_rect.X;
1151 bitmap->locky = act_rect.Y;
1152
1153 image_unlock(&bitmap->image, unlock);
1154 return Ok;
1155 }
1156
1157 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
1158 {
1159 TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
1160
1161 if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
1162 return InvalidParameter;
1163
1164 bitmap->image.xres = xdpi;
1165 bitmap->image.yres = ydpi;
1166
1167 return Ok;
1168 }
1169
1170 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
1171 BitmapData* lockeddata)
1172 {
1173 GpStatus stat;
1174 static BOOL fixme = FALSE;
1175 BOOL unlock;
1176
1177 TRACE("(%p,%p)\n", bitmap, lockeddata);
1178
1179 if(!bitmap || !lockeddata)
1180 return InvalidParameter;
1181 if(!image_lock(&bitmap->image, &unlock))
1182 return ObjectBusy;
1183
1184 if(!bitmap->lockmode)
1185 {
1186 image_unlock(&bitmap->image, unlock);
1187 return WrongState;
1188 }
1189
1190 if(!(lockeddata->Reserved & ImageLockModeWrite)){
1191 bitmap->lockmode = 0;
1192 heap_free(bitmap->bitmapbits);
1193 bitmap->bitmapbits = NULL;
1194 image_unlock(&bitmap->image, unlock);
1195 return Ok;
1196 }
1197
1198 if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
1199 {
1200 /* we passed a direct reference; no need to do anything */
1201 bitmap->lockmode = 0;
1202 image_unlock(&bitmap->image, unlock);
1203 return Ok;
1204 }
1205
1206 if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
1207 {
1208 FIXME("Cannot copy rows that don't start at a whole byte.\n");
1209 fixme = TRUE;
1210 }
1211
1212 stat = convert_pixels(lockeddata->Width, lockeddata->Height,
1213 bitmap->stride,
1214 bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
1215 bitmap->format,
1216 lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
1217
1218 if (stat != Ok)
1219 {
1220 ERR("failed to convert pixels; this should never happen\n");
1221 }
1222
1223 heap_free(bitmap->bitmapbits);
1224 bitmap->bitmapbits = NULL;
1225 bitmap->lockmode = 0;
1226
1227 image_unlock(&bitmap->image, unlock);
1228 return stat;
1229 }
1230
1231 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
1232 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1233 {
1234 Rect area;
1235 GpStatus stat;
1236
1237 TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1238
1239 if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
1240 x < 0 || y < 0 ||
1241 x + width > srcBitmap->width || y + height > srcBitmap->height)
1242 {
1243 TRACE("<-- InvalidParameter\n");
1244 return InvalidParameter;
1245 }
1246
1247 if (format == PixelFormatDontCare)
1248 format = srcBitmap->format;
1249
1250 area.X = gdip_round(x);
1251 area.Y = gdip_round(y);
1252 area.Width = gdip_round(width);
1253 area.Height = gdip_round(height);
1254
1255 stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
1256 if (stat == Ok)
1257 {
1258 stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
1259 srcBitmap->stride,
1260 srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
1261 srcBitmap->format, srcBitmap->image.palette);
1262
1263 if (stat == Ok && srcBitmap->image.palette)
1264 {
1265 ColorPalette *src_palette, *dst_palette;
1266
1267 src_palette = srcBitmap->image.palette;
1268
1269 dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
1270
1271 if (dst_palette)
1272 {
1273 dst_palette->Flags = src_palette->Flags;
1274 dst_palette->Count = src_palette->Count;
1275 memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
1276
1277 heap_free((*dstBitmap)->image.palette);
1278 (*dstBitmap)->image.palette = dst_palette;
1279 }
1280 else
1281 stat = OutOfMemory;
1282 }
1283
1284 if (stat != Ok)
1285 GdipDisposeImage(&(*dstBitmap)->image);
1286 }
1287
1288 if (stat != Ok)
1289 *dstBitmap = NULL;
1290
1291 return stat;
1292 }
1293
1294 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
1295 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1296 {
1297 TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1298
1299 return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
1300 }
1301
1302 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
1303 {
1304 TRACE("%p, %p\n", image, cloneImage);
1305
1306 if (!image || !cloneImage)
1307 return InvalidParameter;
1308
1309 if (image->type == ImageTypeBitmap)
1310 {
1311 GpBitmap *bitmap = (GpBitmap *)image;
1312
1313 return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
1314 bitmap->format, bitmap, (GpBitmap **)cloneImage);
1315 }
1316 else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
1317 {
1318 GpMetafile *result, *metafile;
1319
1320 metafile = (GpMetafile*)image;
1321
1322 result = heap_alloc_zero(sizeof(*result));
1323 if (!result)
1324 return OutOfMemory;
1325
1326 result->image.type = ImageTypeMetafile;
1327 result->image.format = image->format;
1328 result->image.flags = image->flags;
1329 result->image.frame_count = 1;
1330 result->image.xres = image->xres;
1331 result->image.yres = image->yres;
1332 result->bounds = metafile->bounds;
1333 result->unit = metafile->unit;
1334 result->metafile_type = metafile->metafile_type;
1335 result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
1336 list_init(&result->containers);
1337
1338 if (!result->hemf)
1339 {
1340 heap_free(result);
1341 return OutOfMemory;
1342 }
1343
1344 *cloneImage = &result->image;
1345 return Ok;
1346 }
1347 else
1348 {
1349 WARN("GpImage with no image data (metafile in wrong state?)\n");
1350 return InvalidParameter;
1351 }
1352 }
1353
1354 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
1355 GpBitmap **bitmap)
1356 {
1357 GpStatus stat;
1358 IStream *stream;
1359
1360 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1361
1362 if(!filename || !bitmap)
1363 return InvalidParameter;
1364
1365 *bitmap = NULL;
1366
1367 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1368
1369 if(stat != Ok)
1370 return stat;
1371
1372 stat = GdipCreateBitmapFromStream(stream, bitmap);
1373
1374 IStream_Release(stream);
1375
1376 return stat;
1377 }
1378
1379 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
1380 VOID *bits, GpBitmap **bitmap)
1381 {
1382 DWORD height, stride;
1383 PixelFormat format;
1384
1385 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
1386
1387 if (!info || !bits || !bitmap)
1388 return InvalidParameter;
1389
1390 height = abs(info->bmiHeader.biHeight);
1391 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
1392
1393 if(info->bmiHeader.biHeight > 0) /* bottom-up */
1394 {
1395 bits = (BYTE*)bits + (height - 1) * stride;
1396 stride = -stride;
1397 }
1398
1399 switch(info->bmiHeader.biBitCount) {
1400 case 1:
1401 format = PixelFormat1bppIndexed;
1402 break;
1403 case 4:
1404 format = PixelFormat4bppIndexed;
1405 break;
1406 case 8:
1407 format = PixelFormat8bppIndexed;
1408 break;
1409 case 16:
1410 format = PixelFormat16bppRGB555;
1411 break;
1412 case 24:
1413 format = PixelFormat24bppRGB;
1414 break;
1415 case 32:
1416 format = PixelFormat32bppRGB;
1417 break;
1418 default:
1419 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
1420 *bitmap = NULL;
1421 return InvalidParameter;
1422 }
1423
1424 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
1425 bits, bitmap);
1426
1427 }
1428
1429 /* FIXME: no icm */
1430 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
1431 GpBitmap **bitmap)
1432 {
1433 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1434
1435 return GdipCreateBitmapFromFile(filename, bitmap);
1436 }
1437
1438 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
1439 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
1440 {
1441 HBITMAP hbm;
1442 GpStatus stat = InvalidParameter;
1443
1444 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
1445
1446 if(!lpBitmapName || !bitmap)
1447 return InvalidParameter;
1448
1449 /* load DIB */
1450 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
1451 LR_CREATEDIBSECTION);
1452
1453 if(hbm){
1454 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
1455 DeleteObject(hbm);
1456 }
1457
1458 return stat;
1459 }
1460
1461 static inline DWORD blend_argb_no_bkgnd_alpha(DWORD src, DWORD bkgnd)
1462 {
1463 BYTE b = (BYTE)src;
1464 BYTE g = (BYTE)(src >> 8);
1465 BYTE r = (BYTE)(src >> 16);
1466 DWORD alpha = (BYTE)(src >> 24);
1467 return ((b + ((BYTE)bkgnd * (255 - alpha) + 127) / 255) |
1468 (g + ((BYTE)(bkgnd >> 8) * (255 - alpha) + 127) / 255) << 8 |
1469 (r + ((BYTE)(bkgnd >> 16) * (255 - alpha) + 127) / 255) << 16 |
1470 (alpha << 24));
1471 }
1472
1473 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
1474 HBITMAP* hbmReturn, ARGB background)
1475 {
1476 GpStatus stat;
1477 HBITMAP result;
1478 UINT width, height;
1479 BITMAPINFOHEADER bih;
1480 LPBYTE bits;
1481 BOOL unlock;
1482
1483 TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
1484
1485 if (!bitmap || !hbmReturn) return InvalidParameter;
1486 if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
1487
1488 GdipGetImageWidth(&bitmap->image, &width);
1489 GdipGetImageHeight(&bitmap->image, &height);
1490
1491 bih.biSize = sizeof(bih);
1492 bih.biWidth = width;
1493 bih.biHeight = height;
1494 bih.biPlanes = 1;
1495 bih.biBitCount = 32;
1496 bih.biCompression = BI_RGB;
1497 bih.biSizeImage = 0;
1498 bih.biXPelsPerMeter = 0;
1499 bih.biYPelsPerMeter = 0;
1500 bih.biClrUsed = 0;
1501 bih.biClrImportant = 0;
1502
1503 result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1504 if (!result)
1505 {
1506 image_unlock(&bitmap->image, unlock);
1507 return GenericError;
1508 }
1509
1510 stat = convert_pixels(width, height, -width*4,
1511 bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB,
1512 bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
1513 if (stat != Ok)
1514 {
1515 DeleteObject(result);
1516 image_unlock(&bitmap->image, unlock);
1517 return stat;
1518 }
1519
1520 if (background & 0xffffff)
1521 {
1522 DWORD *ptr;
1523 UINT i;
1524 for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
1525 {
1526 if ((*ptr & 0xff000000) == 0xff000000) continue;
1527 *ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
1528 }
1529 }
1530
1531 *hbmReturn = result;
1532 image_unlock(&bitmap->image, unlock);
1533 return Ok;
1534 }
1535
1536 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
1537 GpGraphics* target, GpBitmap** bitmap)
1538 {
1539 GpStatus ret;
1540
1541 TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
1542
1543 if(!target || !bitmap)
1544 return InvalidParameter;
1545
1546 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
1547 NULL, bitmap);
1548
1549 if (ret == Ok)
1550 {
1551 GdipGetDpiX(target, &(*bitmap)->image.xres);
1552 GdipGetDpiY(target, &(*bitmap)->image.yres);
1553 }
1554
1555 return ret;
1556 }
1557
1558 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
1559 {
1560 GpStatus stat;
1561 ICONINFO iinfo;
1562 BITMAP bm;
1563 int ret;
1564 UINT width, height, stride;
1565 GpRect rect;
1566 BitmapData lockeddata;
1567 HDC screendc;
1568 BOOL has_alpha;
1569 int x, y;
1570 BITMAPINFOHEADER bih;
1571 DWORD *src;
1572 BYTE *dst_row;
1573 DWORD *dst;
1574
1575 TRACE("%p, %p\n", hicon, bitmap);
1576
1577 if(!bitmap || !GetIconInfo(hicon, &iinfo))
1578 return InvalidParameter;
1579
1580 /* get the size of the icon */
1581 ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
1582 if (ret == 0) {
1583 DeleteObject(iinfo.hbmColor);
1584 DeleteObject(iinfo.hbmMask);
1585 return GenericError;
1586 }
1587
1588 width = bm.bmWidth;
1589 height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
1590 stride = width * 4;
1591
1592 stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
1593 if (stat != Ok) {
1594 DeleteObject(iinfo.hbmColor);
1595 DeleteObject(iinfo.hbmMask);
1596 return stat;
1597 }
1598
1599 rect.X = 0;
1600 rect.Y = 0;
1601 rect.Width = width;
1602 rect.Height = height;
1603
1604 stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
1605 if (stat != Ok) {
1606 DeleteObject(iinfo.hbmColor);
1607 DeleteObject(iinfo.hbmMask);
1608 GdipDisposeImage(&(*bitmap)->image);
1609 return stat;
1610 }
1611
1612 bih.biSize = sizeof(bih);
1613 bih.biWidth = width;
1614 bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
1615 bih.biPlanes = 1;
1616 bih.biBitCount = 32;
1617 bih.biCompression = BI_RGB;
1618 bih.biSizeImage = 0;
1619 bih.biXPelsPerMeter = 0;
1620 bih.biYPelsPerMeter = 0;
1621 bih.biClrUsed = 0;
1622 bih.biClrImportant = 0;
1623
1624 screendc = CreateCompatibleDC(0);
1625 if (iinfo.hbmColor)
1626 {
1627 GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1628
1629 if (bm.bmBitsPixel == 32)
1630 {
1631 has_alpha = FALSE;
1632
1633 /* If any pixel has a non-zero alpha, ignore hbmMask */
1634 src = (DWORD*)lockeddata.Scan0;
1635 for (x=0; x<width && !has_alpha; x++)
1636 for (y=0; y<height && !has_alpha; y++)
1637 if ((*src++ & 0xff000000) != 0)
1638 has_alpha = TRUE;
1639 }
1640 else has_alpha = FALSE;
1641 }
1642 else
1643 {
1644 GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1645 has_alpha = FALSE;
1646 }
1647
1648 if (!has_alpha)
1649 {
1650 if (iinfo.hbmMask)
1651 {
1652 BYTE *bits = heap_alloc(height * stride);
1653
1654 /* read alpha data from the mask */
1655 if (iinfo.hbmColor)
1656 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1657 else
1658 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1659
1660 src = (DWORD*)bits;
1661 dst_row = lockeddata.Scan0;
1662 for (y=0; y<height; y++)
1663 {
1664 dst = (DWORD*)dst_row;
1665 for (x=0; x<height; x++)
1666 {
1667 DWORD src_value = *src++;
1668 if (src_value)
1669 *dst++ = 0;
1670 else
1671 *dst++ |= 0xff000000;
1672 }
1673 dst_row += lockeddata.Stride;
1674 }
1675
1676 heap_free(bits);
1677 }
1678 else
1679 {
1680 /* set constant alpha of 255 */
1681 dst_row = lockeddata.Scan0;
1682 for (y=0; y<height; y++)
1683 {
1684 dst = (DWORD*)dst_row;
1685 for (x=0; x<height; x++)
1686 *dst++ |= 0xff000000;
1687 dst_row += lockeddata.Stride;
1688 }
1689 }
1690 }
1691
1692 DeleteDC(screendc);
1693
1694 DeleteObject(iinfo.hbmColor);
1695 DeleteObject(iinfo.hbmMask);
1696
1697 GdipBitmapUnlockBits(*bitmap, &lockeddata);
1698
1699 return Ok;
1700 }
1701
1702 static void generate_halftone_palette(ARGB *entries, UINT count)
1703 {
1704 static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1705 UINT i;
1706
1707 for (i=0; i<8 && i<count; i++)
1708 {
1709 entries[i] = 0xff000000;
1710 if (i&1) entries[i] |= 0x800000;
1711 if (i&2) entries[i] |= 0x8000;
1712 if (i&4) entries[i] |= 0x80;
1713 }
1714
1715 if (8 < count)
1716 entries[i] = 0xffc0c0c0;
1717
1718 for (i=9; i<16 && i<count; i++)
1719 {
1720 entries[i] = 0xff000000;
1721 if (i&1) entries[i] |= 0xff0000;
1722 if (i&2) entries[i] |= 0xff00;
1723 if (i&4) entries[i] |= 0xff;
1724 }
1725
1726 for (i=16; i<40 && i<count; i++)
1727 {
1728 entries[i] = 0;
1729 }
1730
1731 for (i=40; i<256 && i<count; i++)
1732 {
1733 entries[i] = 0xff000000;
1734 entries[i] |= halftone_values[(i-40)%6];
1735 entries[i] |= halftone_values[((i-40)/6)%6] << 8;
1736 entries[i] |= halftone_values[((i-40)/36)%6] << 16;
1737 }
1738 }
1739
1740 static GpStatus get_screen_resolution(REAL *xres, REAL *yres)
1741 {
1742 HDC screendc = CreateCompatibleDC(0);
1743
1744 if (!screendc) return GenericError;
1745
1746 *xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
1747 *yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
1748
1749 DeleteDC(screendc);
1750
1751 return Ok;
1752 }
1753
1754 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1755 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1756 {
1757 HBITMAP hbitmap=NULL;
1758 INT row_size, dib_stride;
1759 BYTE *bits=NULL, *own_bits=NULL;
1760 REAL xres, yres;
1761 GpStatus stat;
1762
1763 TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
1764
1765 if (!bitmap) return InvalidParameter;
1766
1767 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1768 *bitmap = NULL;
1769 return InvalidParameter;
1770 }
1771
1772 if(scan0 && !stride)
1773 return InvalidParameter;
1774
1775 stat = get_screen_resolution(&xres, &yres);
1776 if (stat != Ok) return stat;
1777
1778 row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1779 dib_stride = (row_size + 3) & ~3;
1780
1781 if(stride == 0)
1782 stride = dib_stride;
1783
1784 if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
1785 {
1786 char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
1787 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
1788
1789 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1790 pbmi->bmiHeader.biWidth = width;
1791 pbmi->bmiHeader.biHeight = -height;
1792 pbmi->bmiHeader.biPlanes = 1;
1793 /* FIXME: use the rest of the data from format */
1794 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
1795 pbmi->bmiHeader.biCompression = BI_RGB;
1796 pbmi->bmiHeader.biSizeImage = 0;
1797 pbmi->bmiHeader.biXPelsPerMeter = 0;
1798 pbmi->bmiHeader.biYPelsPerMeter = 0;
1799 pbmi->bmiHeader.biClrUsed = 0;
1800 pbmi->bmiHeader.biClrImportant = 0;
1801
1802 hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1803
1804 if (!hbitmap) return GenericError;
1805
1806 stride = dib_stride;
1807 }
1808 else
1809 {
1810 /* Not a GDI format; don't try to make an HBITMAP. */
1811 if (scan0)
1812 bits = scan0;
1813 else
1814 {
1815 INT size = abs(stride) * height;
1816
1817 own_bits = bits = heap_alloc_zero(size);
1818 if (!own_bits) return OutOfMemory;
1819
1820 if (stride < 0)
1821 bits += stride * (1 - height);
1822 }
1823 }
1824
1825 *bitmap = heap_alloc_zero(sizeof(GpBitmap));
1826 if(!*bitmap)
1827 {
1828 DeleteObject(hbitmap);
1829 heap_free(own_bits);
1830 return OutOfMemory;
1831 }
1832
1833 (*bitmap)->image.type = ImageTypeBitmap;
1834 memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1835 (*bitmap)->image.flags = ImageFlagsNone;
1836 (*bitmap)->image.frame_count = 1;
1837 (*bitmap)->image.current_frame = 0;
1838 (*bitmap)->image.palette = NULL;
1839 (*bitmap)->image.xres = xres;
1840 (*bitmap)->image.yres = yres;
1841 (*bitmap)->width = width;
1842 (*bitmap)->height = height;
1843 (*bitmap)->format = format;
1844 (*bitmap)->image.decoder = NULL;
1845 (*bitmap)->hbitmap = hbitmap;
1846 (*bitmap)->hdc = NULL;
1847 (*bitmap)->bits = bits;
1848 (*bitmap)->stride = stride;
1849 (*bitmap)->own_bits = own_bits;
1850 (*bitmap)->metadata_reader = NULL;
1851 (*bitmap)->prop_count = 0;
1852 (*bitmap)->prop_item = NULL;
1853
1854 /* set format-related flags */
1855 if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
1856 (*bitmap)->image.flags |= ImageFlagsHasAlpha;
1857
1858 if (format == PixelFormat1bppIndexed ||
1859 format == PixelFormat4bppIndexed ||
1860 format == PixelFormat8bppIndexed)
1861 {
1862 (*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
1863
1864 if (!(*bitmap)->image.palette)
1865 {
1866 GdipDisposeImage(&(*bitmap)->image);
1867 *bitmap = NULL;
1868 return OutOfMemory;
1869 }
1870
1871 (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
1872
1873 if (format == PixelFormat1bppIndexed)
1874 {
1875 (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
1876 (*bitmap)->image.palette->Entries[0] = 0xff000000;
1877 (*bitmap)->image.palette->Entries[1] = 0xffffffff;
1878 }
1879 else
1880 {
1881 if (format == PixelFormat8bppIndexed)
1882 (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
1883
1884 generate_halftone_palette((*bitmap)->image.palette->Entries,
1885 (*bitmap)->image.palette->Count);
1886 }
1887 }
1888
1889 TRACE("<-- %p\n", *bitmap);
1890
1891 return Ok;
1892 }
1893
1894 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1895 GpBitmap **bitmap)
1896 {
1897 GpStatus stat;
1898
1899 TRACE("%p %p\n", stream, bitmap);
1900
1901 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1902
1903 if(stat != Ok)
1904 return stat;
1905
1906 if((*bitmap)->image.type != ImageTypeBitmap){
1907 GdipDisposeImage(&(*bitmap)->image);
1908 *bitmap = NULL;
1909 return GenericError; /* FIXME: what error to return? */
1910 }
1911
1912 return Ok;
1913 }
1914
1915 /* FIXME: no icm */
1916 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1917 GpBitmap **bitmap)
1918 {
1919 TRACE("%p %p\n", stream, bitmap);
1920
1921 return GdipCreateBitmapFromStream(stream, bitmap);
1922 }
1923
1924 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1925 GpCachedBitmap **cachedbmp)
1926 {
1927 GpStatus stat;
1928
1929 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1930
1931 if(!bitmap || !graphics || !cachedbmp)
1932 return InvalidParameter;
1933
1934 *cachedbmp = heap_alloc_zero(sizeof(GpCachedBitmap));
1935 if(!*cachedbmp)
1936 return OutOfMemory;
1937
1938 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1939 if(stat != Ok){
1940 heap_free(*cachedbmp);
1941 return stat;
1942 }
1943
1944 return Ok;
1945 }
1946
1947 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1948 {
1949 GpStatus stat;
1950 BitmapData lockeddata;
1951 ULONG andstride, xorstride, bitssize;
1952 LPBYTE andbits, xorbits, androw, xorrow, srcrow;
1953 UINT x, y;
1954
1955 TRACE("(%p, %p)\n", bitmap, hicon);
1956
1957 if (!bitmap || !hicon)
1958 return InvalidParameter;
1959
1960 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
1961 PixelFormat32bppPARGB, &lockeddata);
1962 if (stat == Ok)
1963 {
1964 andstride = ((lockeddata.Width+31)/32)*4;
1965 xorstride = lockeddata.Width*4;
1966 bitssize = (andstride + xorstride) * lockeddata.Height;
1967
1968 andbits = heap_alloc_zero(bitssize);
1969
1970 if (andbits)
1971 {
1972 xorbits = andbits + andstride * lockeddata.Height;
1973
1974 for (y=0; y<lockeddata.Height; y++)
1975 {
1976 srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
1977
1978 androw = andbits + andstride * y;
1979 for (x=0; x<lockeddata.Width; x++)
1980 if (srcrow[3+4*x] >= 128)
1981 androw[x/8] |= 1 << (7-x%8);
1982
1983 xorrow = xorbits + xorstride * y;
1984 memcpy(xorrow, srcrow, xorstride);
1985 }
1986
1987 *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
1988 andbits, xorbits);
1989
1990 heap_free(andbits);
1991 }
1992 else
1993 stat = OutOfMemory;
1994
1995 GdipBitmapUnlockBits(bitmap, &lockeddata);
1996 }
1997
1998 return stat;
1999 }
2000
2001 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
2002 {
2003 TRACE("%p\n", cachedbmp);
2004
2005 if(!cachedbmp)
2006 return InvalidParameter;
2007
2008 GdipDisposeImage(cachedbmp->image);
2009 heap_free(cachedbmp);
2010
2011 return Ok;
2012 }
2013
2014 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
2015 GpCachedBitmap *cachedbmp, INT x, INT y)
2016 {
2017 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
2018
2019 if(!graphics || !cachedbmp)
2020 return InvalidParameter;
2021
2022 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
2023 }
2024
2025 /* Internal utility function: Replace the image data of dst with that of src,
2026 * and free src. */
2027 static void move_bitmap(GpBitmap *dst, GpBitmap *src, BOOL clobber_palette)
2028 {
2029 assert(src->image.type == ImageTypeBitmap);
2030 assert(dst->image.type == ImageTypeBitmap);
2031
2032 heap_free(dst->bitmapbits);
2033 heap_free(dst->own_bits);
2034 DeleteDC(dst->hdc);
2035 DeleteObject(dst->hbitmap);
2036
2037 if (clobber_palette)
2038 {
2039 heap_free(dst->image.palette);
2040 dst->image.palette = src->image.palette;
2041 }
2042 else
2043 heap_free(src->image.palette);
2044
2045 dst->image.xres = src->image.xres;
2046 dst->image.yres = src->image.yres;
2047 dst->width = src->width;
2048 dst->height = src->height;
2049 dst->format = src->format;
2050 dst->hbitmap = src->hbitmap;
2051 dst->hdc = src->hdc;
2052 dst->bits = src->bits;
2053 dst->stride = src->stride;
2054 dst->own_bits = src->own_bits;
2055 if (dst->metadata_reader)
2056 IWICMetadataReader_Release(dst->metadata_reader);
2057 dst->metadata_reader = src->metadata_reader;
2058 heap_free(dst->prop_item);
2059 dst->prop_item = src->prop_item;
2060 dst->prop_count = src->prop_count;
2061 if (dst->image.decoder)
2062 IWICBitmapDecoder_Release(dst->image.decoder);
2063 dst->image.decoder = src->image.decoder;
2064 dst->image.frame_count = src->image.frame_count;
2065 dst->image.current_frame = src->image.current_frame;
2066 dst->image.format = src->image.format;
2067
2068 src->image.type = ~0;
2069 heap_free(src);
2070 }
2071
2072 static GpStatus free_image_data(GpImage *image)
2073 {
2074 if(!image)
2075 return InvalidParameter;
2076
2077 if (image->type == ImageTypeBitmap)
2078 {
2079 heap_free(((GpBitmap*)image)->bitmapbits);
2080 heap_free(((GpBitmap*)image)->own_bits);
2081 DeleteDC(((GpBitmap*)image)->hdc);
2082 DeleteObject(((GpBitmap*)image)->hbitmap);
2083 if (((GpBitmap*)image)->metadata_reader)
2084 IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2085 heap_free(((GpBitmap*)image)->prop_item);
2086 }
2087 else if (image->type == ImageTypeMetafile)
2088 METAFILE_Free((GpMetafile *)image);
2089 else
2090 {
2091 WARN("invalid image: %p\n", image);
2092 return ObjectBusy;
2093 }
2094 if (image->decoder)
2095 IWICBitmapDecoder_Release(image->decoder);
2096 heap_free(image->palette);
2097
2098 return Ok;
2099 }
2100
2101 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2102 {
2103 GpStatus status;
2104
2105 TRACE("%p\n", image);
2106
2107 status = free_image_data(image);
2108 if (status != Ok) return status;
2109 image->type = ~0;
2110 heap_free(image);
2111
2112 return Ok;
2113 }
2114
2115 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2116 {
2117 static int calls;
2118
2119 TRACE("(%p,%p)\n", image, item);
2120
2121 if(!image || !item)
2122 return InvalidParameter;
2123
2124 if (!(calls++))
2125 FIXME("not implemented\n");
2126
2127 return NotImplemented;
2128 }
2129
2130 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2131 {
2132 static int calls;
2133
2134 TRACE("(%p,%p)\n", image, item);
2135
2136 if (!(calls++))
2137 FIXME("not implemented\n");
2138
2139 return NotImplemented;
2140 }
2141
2142 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2143 GpUnit *srcUnit)
2144 {
2145 TRACE("%p %p %p\n", image, srcRect, srcUnit);
2146
2147 if(!image || !srcRect || !srcUnit)
2148 return InvalidParameter;
2149 if(image->type == ImageTypeMetafile){
2150 *srcRect = ((GpMetafile*)image)->bounds;
2151 *srcUnit = ((GpMetafile*)image)->unit;
2152 }
2153 else if(image->type == ImageTypeBitmap){
2154 srcRect->X = srcRect->Y = 0.0;
2155 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2156 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2157 *srcUnit = UnitPixel;
2158 }
2159 else{
2160 WARN("GpImage with no image data\n");
2161 return InvalidParameter;
2162 }
2163
2164 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2165 srcRect->Width, srcRect->Height, *srcUnit);
2166
2167 return Ok;
2168 }
2169
2170 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2171 REAL *height)
2172 {
2173 TRACE("%p %p %p\n", image, width, height);
2174
2175 if(!image || !height || !width)
2176 return InvalidParameter;
2177
2178 if(image->type == ImageTypeMetafile){
2179 *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2180 *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2181 }
2182 else if(image->type == ImageTypeBitmap){
2183 *height = ((GpBitmap*)image)->height;
2184 *width = ((GpBitmap*)image)->width;
2185 }
2186 else{
2187 WARN("GpImage with no image data\n");
2188 return InvalidParameter;
2189 }
2190
2191 TRACE("returning (%f, %f)\n", *height, *width);
2192 return Ok;
2193 }
2194
2195 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2196 GpGraphics **graphics)
2197 {
2198 HDC hdc;
2199 GpStatus stat;
2200
2201 TRACE("%p %p\n", image, graphics);
2202
2203 if(!image || !graphics)
2204 return InvalidParameter;
2205
2206 if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2207 {
2208 hdc = ((GpBitmap*)image)->hdc;
2209
2210 if(!hdc){
2211 hdc = CreateCompatibleDC(0);
2212 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2213 ((GpBitmap*)image)->hdc = hdc;
2214 }
2215
2216 stat = GdipCreateFromHDC(hdc, graphics);
2217
2218 if (stat == Ok)
2219 {
2220 (*graphics)->image = image;
2221 (*graphics)->xres = image->xres;
2222 (*graphics)->yres = image->yres;
2223 }
2224 }
2225 else if (image->type == ImageTypeMetafile)
2226 stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2227 else
2228 stat = graphics_from_image(image, graphics);
2229
2230 return stat;
2231 }
2232
2233 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2234 {
2235 TRACE("%p %p\n", image, height);
2236
2237 if(!image || !height)
2238 return InvalidParameter;
2239
2240 if(image->type == ImageTypeMetafile)
2241 *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2242 else if(image->type == ImageTypeBitmap)
2243 *height = ((GpBitmap*)image)->height;
2244 else
2245 {
2246 WARN("GpImage with no image data\n");
2247 return InvalidParameter;
2248 }
2249
2250 TRACE("returning %d\n", *height);
2251
2252 return Ok;
2253 }
2254
2255 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2256 {
2257 if(!image || !res)
2258 return InvalidParameter;
2259
2260 *res = image->xres;
2261
2262 TRACE("(%p) <-- %0.2f\n", image, *res);
2263
2264 return Ok;
2265 }
2266
2267 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2268 {
2269 TRACE("%p %p\n", image, size);
2270
2271 if(!image || !size)
2272 return InvalidParameter;
2273
2274 if (!image->palette || image->palette->Count == 0)
2275 *size = sizeof(ColorPalette);
2276 else
2277 *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
2278
2279 TRACE("<-- %u\n", *size);
2280
2281 return Ok;
2282 }
2283
2284 /* FIXME: test this function for non-bitmap types */
2285 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2286 {
2287 TRACE("%p %p\n", image, format);
2288
2289 if(!image || !format)
2290 return InvalidParameter;
2291
2292 if(image->type != ImageTypeBitmap)
2293 *format = PixelFormat24bppRGB;
2294 else
2295 *format = ((GpBitmap*) image)->format;
2296
2297 return Ok;
2298 }
2299
2300 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2301 {
2302 TRACE("(%p, %p)\n", image, format);
2303
2304 if(!image || !format)
2305 return InvalidParameter;
2306
2307 memcpy(format, &image->format, sizeof(GUID));
2308
2309 return Ok;
2310 }
2311
2312 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2313 {
2314 TRACE("%p %p\n", image, type);
2315
2316 if(!image || !type)
2317 return InvalidParameter;
2318
2319 *type = image->type;
2320
2321 return Ok;
2322 }
2323
2324 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2325 {
2326 if(!image || !res)
2327 return InvalidParameter;
2328
2329 *res = image->yres;
2330
2331 TRACE("(%p) <-- %0.2f\n", image, *res);
2332
2333 return Ok;
2334 }
2335
2336 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2337 {
2338 TRACE("%p %p\n", image, width);
2339
2340 if(!image || !width)
2341 return InvalidParameter;
2342
2343 if(image->type == ImageTypeMetafile)
2344 *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2345 else if(image->type == ImageTypeBitmap)
2346 *width = ((GpBitmap*)image)->width;
2347 else
2348 {
2349 WARN("GpImage with no image data\n");
2350 return InvalidParameter;
2351 }
2352
2353 TRACE("returning %d\n", *width);
2354
2355 return Ok;
2356 }
2357
2358 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2359 {
2360 TRACE("(%p, %p)\n", image, num);
2361
2362 if (!image || !num) return InvalidParameter;
2363
2364 *num = 0;
2365
2366 if (image->type == ImageTypeBitmap)
2367 {
2368 if (((GpBitmap *)image)->prop_item)
2369 {
2370 *num = ((GpBitmap *)image)->prop_count;
2371 return Ok;
2372 }
2373
2374 if (((GpBitmap *)image)->metadata_reader)
2375 IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2376 }
2377
2378 return Ok;
2379 }
2380
2381 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2382 {
2383 HRESULT hr;
2384 IWICMetadataReader *reader;
2385 IWICEnumMetadataItem *enumerator;
2386 UINT prop_count, i, items_returned;
2387
2388 TRACE("(%p, %u, %p)\n", image, num, list);
2389
2390 if (!image || !list) return InvalidParameter;
2391
2392 if (image->type != ImageTypeBitmap)
2393 {
2394 FIXME("Not implemented for type %d\n", image->type);
2395 return NotImplemented;
2396 }
2397
2398 if (((GpBitmap *)image)->prop_item)
2399 {
2400 if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
2401
2402 for (i = 0; i < num; i++)
2403 {
2404 list[i] = ((GpBitmap *)image)->prop_item[i].id;
2405 }
2406
2407 return Ok;
2408 }
2409
2410 reader = ((GpBitmap *)image)->metadata_reader;
2411 if (!reader)
2412 {
2413 if (num != 0) return InvalidParameter;
2414 return Ok;
2415 }
2416
2417 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2418 if (FAILED(hr)) return hresult_to_status(hr);
2419
2420 if (num != prop_count) return InvalidParameter;
2421
2422 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2423 if (FAILED(hr)) return hresult_to_status(hr);
2424
2425 IWICEnumMetadataItem_Reset(enumerator);
2426
2427 for (i = 0; i < num; i++)
2428 {
2429 PROPVARIANT id;
2430
2431 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2432 if (hr != S_OK) break;
2433
2434 if (id.vt != VT_UI2)
2435 {
2436 FIXME("not supported propvariant type for id: %u\n", id.vt);
2437 list[i] = 0;
2438 continue;
2439 }
2440 list[i] = id.u.uiVal;
2441 }
2442
2443 IWICEnumMetadataItem_Release(enumerator);
2444
2445 return hr == S_OK ? Ok : hresult_to_status(hr);
2446 }
2447
2448 static UINT propvariant_size(PROPVARIANT *value)
2449 {
2450 switch (value->vt & ~VT_VECTOR)
2451 {
2452 case VT_EMPTY:
2453 return 0;
2454 case VT_I1:
2455 case VT_UI1:
2456 if (!(value->vt & VT_VECTOR)) return 1;
2457 return value->u.caub.cElems;
2458 case VT_I2:
2459 case VT_UI2:
2460 if (!(value->vt & VT_VECTOR)) return 2;
2461 return value->u.caui.cElems * 2;
2462 case VT_I4:
2463 case VT_UI4:
2464 case VT_R4:
2465 if (!(value->vt & VT_VECTOR)) return 4;
2466 return value->u.caul.cElems * 4;
2467 case VT_I8:
2468 case VT_UI8:
2469 case VT_R8:
2470 if (!(value->vt & VT_VECTOR)) return 8;
2471 return value->u.cauh.cElems * 8;
2472 case VT_LPSTR:
2473 return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2474 case VT_BLOB:
2475 return value->u.blob.cbSize;
2476 default:
2477 FIXME("not supported variant type %d\n", value->vt);
2478 return 0;
2479 }
2480 }
2481
2482 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2483 {
2484 HRESULT hr;
2485 IWICMetadataReader *reader;
2486 PROPVARIANT id, value;
2487
2488 TRACE("(%p,%#x,%p)\n", image, propid, size);
2489
2490 if (!size || !image) return InvalidParameter;
2491
2492 if (image->type != ImageTypeBitmap)
2493 {
2494 FIXME("Not implemented for type %d\n", image->type);
2495 return NotImplemented;
2496 }
2497
2498 if (((GpBitmap *)image)->prop_item)
2499 {
2500 UINT i;
2501
2502 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2503 {
2504 if (propid == ((GpBitmap *)image)->prop_item[i].id)
2505 {
2506 *size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2507 return Ok;
2508 }
2509 }
2510
2511 return PropertyNotFound;
2512 }
2513
2514 reader = ((GpBitmap *)image)->metadata_reader;
2515 if (!reader) return PropertyNotFound;
2516
2517 id.vt = VT_UI2;
2518 id.u.uiVal = propid;
2519 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2520 if (FAILED(hr)) return PropertyNotFound;
2521
2522 *size = propvariant_size(&value);
2523 if (*size) *size += sizeof(PropertyItem);
2524 PropVariantClear(&value);
2525
2526 return Ok;
2527 }
2528
2529 #ifndef PropertyTagTypeSByte
2530 #define PropertyTagTypeSByte 6
2531 #define PropertyTagTypeSShort 8
2532 #define PropertyTagTypeFloat 11
2533 #define PropertyTagTypeDouble 12
2534 #endif
2535
2536 static UINT vt_to_itemtype(UINT vt)
2537 {
2538 static const struct
2539 {
2540 UINT vt, type;
2541 } vt2type[] =
2542 {
2543 { VT_I1, PropertyTagTypeSByte },
2544 { VT_UI1, PropertyTagTypeByte },
2545 { VT_I2, PropertyTagTypeSShort },
2546 { VT_UI2, PropertyTagTypeShort },
2547 { VT_I4, PropertyTagTypeSLONG },
2548 { VT_UI4, PropertyTagTypeLong },
2549 { VT_I8, PropertyTagTypeSRational },
2550 { VT_UI8, PropertyTagTypeRational },
2551 { VT_R4, PropertyTagTypeFloat },
2552 { VT_R8, PropertyTagTypeDouble },
2553 { VT_LPSTR, PropertyTagTypeASCII },
2554 { VT_BLOB, PropertyTagTypeUndefined }
2555 };
2556 UINT i;
2557 for (i = 0; i < sizeof(vt2type)/sizeof(vt2type[0]); i++)
2558 {
2559 if (vt2type[i].vt == vt) return vt2type[i].type;
2560 }
2561 FIXME("not supported variant type %u\n", vt);
2562 return 0;
2563 }
2564
2565 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2566 UINT size, PROPID id)
2567 {
2568 UINT item_size, item_type;
2569
2570 item_size = propvariant_size(value);
2571 if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2572
2573 item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2574 if (!item_type) return InvalidParameter;
2575
2576 item->value = item + 1;
2577
2578 switch (value->vt & ~VT_VECTOR)
2579 {
2580 case VT_I1:
2581 case VT_UI1:
2582 if (!(value->vt & VT_VECTOR))
2583 *(BYTE *)item->value = value->u.bVal;
2584 else
2585 memcpy(item->value, value->u.caub.pElems, item_size);
2586 break;
2587 case VT_I2:
2588 case VT_UI2:
2589 if (!(value->vt & VT_VECTOR))
2590 *(USHORT *)item->value = value->u.uiVal;
2591 else
2592 memcpy(item->value, value->u.caui.pElems, item_size);
2593 break;
2594 case VT_I4:
2595 case VT_UI4:
2596 case VT_R4:
2597 if (!(value->vt & VT_VECTOR))
2598 *(ULONG *)item->value = value->u.ulVal;
2599 else
2600 memcpy(item->value, value->u.caul.pElems, item_size);
2601 break;
2602 case VT_I8:
2603 case VT_UI8:
2604 case VT_R8:
2605 if (!(value->vt & VT_VECTOR))
2606 *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2607 else
2608 memcpy(item->value, value->u.cauh.pElems, item_size);
2609 break;
2610 case VT_LPSTR:
2611 memcpy(item->value, value->u.pszVal, item_size);
2612 break;
2613 case VT_BLOB:
2614 memcpy(item->value, value->u.blob.pBlobData, item_size);
2615 break;
2616 default:
2617 FIXME("not supported variant type %d\n", value->vt);
2618 return InvalidParameter;
2619 }
2620
2621 item->length = item_size;
2622 item->type = item_type;
2623 item->id = id;
2624
2625 return Ok;
2626 }
2627
2628 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2629 PropertyItem *buffer)
2630 {
2631 GpStatus stat;
2632 HRESULT hr;
2633 IWICMetadataReader *reader;
2634 PROPVARIANT id, value;
2635
2636 TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2637
2638 if (!image || !buffer) return InvalidParameter;
2639
2640 if (image->type != ImageTypeBitmap)
2641 {
2642 FIXME("Not implemented for type %d\n", image->type);
2643 return NotImplemented;
2644 }
2645
2646 if (((GpBitmap *)image)->prop_item)
2647 {
2648 UINT i;
2649
2650 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2651 {
2652 if (propid == ((GpBitmap *)image)->prop_item[i].id)
2653 {
2654 if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
2655 return InvalidParameter;
2656
2657 *buffer = ((GpBitmap *)image)->prop_item[i];
2658 buffer->value = buffer + 1;
2659 memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
2660 return Ok;
2661 }
2662 }
2663
2664 return PropertyNotFound;
2665 }
2666
2667 reader = ((GpBitmap *)image)->metadata_reader;
2668 if (!reader) return PropertyNotFound;
2669
2670 id.vt = VT_UI2;
2671 id.u.uiVal = propid;
2672 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2673 if (FAILED(hr)) return PropertyNotFound;
2674
2675 stat = propvariant_to_item(&value, buffer, size, propid);
2676 PropVariantClear(&value);
2677
2678 return stat;
2679 }
2680
2681 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2682 {
2683 HRESULT hr;
2684 IWICMetadataReader *reader;
2685 IWICEnumMetadataItem *enumerator;
2686 UINT prop_count, prop_size, i;
2687 PROPVARIANT id, value;
2688
2689 TRACE("(%p,%p,%p)\n", image, size, count);
2690
2691 if (!image || !size || !count) return InvalidParameter;
2692
2693 if (image->type != ImageTypeBitmap)
2694 {
2695 FIXME("Not implemented for type %d\n", image->type);
2696 return NotImplemented;
2697 }
2698
2699 if (((GpBitmap *)image)->prop_item)
2700 {
2701 *count = ((GpBitmap *)image)->prop_count;
2702 *size = 0;
2703
2704 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2705 {
2706 *size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2707 }
2708
2709 return Ok;
2710 }
2711
2712 reader = ((GpBitmap *)image)->metadata_reader;
2713 if (!reader) return PropertyNotFound;
2714
2715 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2716 if (FAILED(hr)) return hresult_to_status(hr);
2717
2718 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2719 if (FAILED(hr)) return hresult_to_status(hr);
2720
2721 IWICEnumMetadataItem_Reset(enumerator);
2722
2723 prop_size = 0;
2724
2725 PropVariantInit(&id);
2726 PropVariantInit(&value);
2727
2728 for (i = 0; i < prop_count; i++)
2729 {
2730 UINT items_returned, item_size;
2731
2732 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2733 if (hr != S_OK) break;
2734
2735 item_size = propvariant_size(&value);
2736 if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2737
2738 PropVariantClear(&id);
2739 PropVariantClear(&value);
2740 }
2741
2742 IWICEnumMetadataItem_Release(enumerator);
2743
2744 if (hr != S_OK) return PropertyNotFound;
2745
2746 *count = prop_count;
2747 *size = prop_size;
2748 return Ok;
2749 }
2750
2751 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2752 UINT count, PropertyItem *buf)
2753 {
2754 GpStatus status;
2755 HRESULT hr;
2756 IWICMetadataReader *reader;
2757 IWICEnumMetadataItem *enumerator;
2758 UINT prop_count, prop_size, i;
2759 PROPVARIANT id, value;
2760 char *item_value;
2761
2762 TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2763
2764 if (!image || !buf) return InvalidParameter;
2765
2766 if (image->type != ImageTypeBitmap)
2767 {
2768 FIXME("Not implemented for type %d\n", image->type);
2769 return NotImplemented;
2770 }
2771
2772 status = GdipGetPropertySize(image, &prop_size, &prop_count);
2773 if (status != Ok) return status;
2774
2775 if (prop_count != count || prop_size != size) return InvalidParameter;
2776
2777 if (((GpBitmap *)image)->prop_item)
2778 {
2779 memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
2780
2781 item_value = (char *)(buf + prop_count);
2782
2783 for (i = 0; i < prop_count; i++)
2784 {
2785 buf[i].value = item_value;
2786 item_value += buf[i].length;
2787 }
2788
2789 return Ok;
2790 }
2791
2792 reader = ((GpBitmap *)image)->metadata_reader;
2793 if (!reader) return PropertyNotFound;
2794
2795 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2796 if (FAILED(hr)) return hresult_to_status(hr);
2797
2798 IWICEnumMetadataItem_Reset(enumerator);
2799
2800 item_value = (char *)(buf + prop_count);
2801
2802 PropVariantInit(&id);
2803 PropVariantInit(&value);
2804
2805 for (i = 0; i < prop_count; i++)
2806 {
2807 PropertyItem *item;
2808 UINT items_returned, item_size;
2809
2810 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2811 if (hr != S_OK) break;
2812
2813 if (id.vt != VT_UI2)
2814 {
2815 FIXME("not supported propvariant type for id: %u\n", id.vt);
2816 continue;
2817 }
2818
2819 item_size = propvariant_size(&value);
2820 if (item_size)
2821 {
2822 item = heap_alloc(item_size + sizeof(*item));
2823
2824 propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2825 buf[i].id = item->id;
2826 buf[i].type = item->type;
2827 buf[i].length = item_size;
2828 buf[i].value = item_value;
2829 memcpy(item_value, item->value, item_size);
2830 item_value += item_size;
2831
2832 heap_free(item);
2833 }
2834
2835 PropVariantClear(&id);
2836 PropVariantClear(&value);
2837 }
2838
2839 IWICEnumMetadataItem_Release(enumerator);
2840
2841 if (hr != S_OK) return PropertyNotFound;
2842
2843 return Ok;
2844 }
2845
2846 struct image_format_dimension
2847 {
2848 const GUID *format;
2849 const GUID *dimension;
2850 };
2851
2852 static const struct image_format_dimension image_format_dimensions[] =
2853 {
2854 {&ImageFormatGIF, &FrameDimensionTime},
2855 {&ImageFormatIcon, &FrameDimensionResolution},
2856 {NULL}
2857 };
2858
2859 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2860 GDIPCONST GUID* dimensionID, UINT* count)
2861 {
2862 TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2863
2864 if(!image || !count)
2865 return InvalidParameter;
2866
2867 if (!dimensionID ||
2868 IsEqualGUID(dimensionID, &image->format) ||
2869 IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2870 IsEqualGUID(dimensionID, &FrameDimensionTime))
2871 {
2872 *count = image->frame_count;
2873 return Ok;
2874 }
2875
2876 return InvalidParameter;
2877 }
2878
2879 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2880 UINT* count)
2881 {
2882 TRACE("(%p, %p)\n", image, count);
2883
2884 /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2885
2886 if(!image || !count)
2887 return InvalidParameter;
2888
2889 *count = 1;
2890
2891 return Ok;
2892 }
2893
2894 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2895 GUID* dimensionIDs, UINT count)
2896 {
2897 int i;
2898 const GUID *result=NULL;
2899
2900 TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2901
2902 if(!image || !dimensionIDs || count != 1)
2903 return InvalidParameter;
2904
2905 for (i=0; image_format_dimensions[i].format; i++)
2906 {
2907 if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2908 {
2909 result = image_format_dimensions[i].dimension;
2910 break;
2911 }
2912 }
2913
2914 if (!result)
2915 result = &FrameDimensionPage;
2916
2917 memcpy(dimensionIDs, result, sizeof(GUID));
2918
2919 return Ok;
2920 }
2921
2922 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2923 GpImage **image)
2924 {
2925 GpStatus stat;
2926 IStream *stream;
2927
2928 TRACE("(%s) %p\n", debugstr_w(filename), image);
2929
2930 if (!filename || !image)
2931 return InvalidParameter;
2932
2933 *image = NULL;
2934
2935 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2936
2937 if (stat != Ok)
2938 return stat;
2939
2940 stat = GdipLoadImageFromStream(stream, image);
2941
2942 IStream_Release(stream);
2943
2944 return stat;
2945 }
2946
2947 /* FIXME: no icm handling */
2948 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2949 {
2950 TRACE("(%s) %p\n", debugstr_w(filename), image);
2951
2952 return GdipLoadImageFromFile(filename, image);
2953 }
2954
2955 static void add_property(GpBitmap *bitmap, PropertyItem *item)
2956 {
2957 UINT prop_size, prop_count;
2958 PropertyItem *prop_item;
2959
2960 if (bitmap->prop_item == NULL)
2961 {
2962 prop_size = prop_count = 0;
2963 prop_item = heap_alloc_zero(item->length + sizeof(PropertyItem));
2964 if (!prop_item) return;
2965 }
2966 else
2967 {
2968 UINT i;
2969 char *item_value;
2970
2971 GdipGetPropertySize(&bitmap->image, &prop_size, &prop_count);
2972
2973 prop_item = heap_alloc_zero(prop_size + item->length + sizeof(PropertyItem));
2974 if (!prop_item) return;
2975 memcpy(prop_item, bitmap->prop_item, sizeof(PropertyItem) * bitmap->prop_count);
2976 prop_size -= sizeof(PropertyItem) * bitmap->prop_count;
2977 memcpy(prop_item + prop_count + 1, bitmap->prop_item + prop_count, prop_size);
2978
2979 item_value = (char *)(prop_item + prop_count + 1);
2980
2981 for (i = 0; i < prop_count; i++)
2982 {
2983 prop_item[i].value = item_value;
2984 item_value += prop_item[i].length;
2985 }
2986 }
2987
2988 prop_item[prop_count].id = item->id;
2989 prop_item[prop_count].type = item->type;
2990 prop_item[prop_count].length = item->length;
2991 prop_item[prop_count].value = (char *)(prop_item + prop_count + 1) + prop_size;
2992 memcpy(prop_item[prop_count].value, item->value, item->length);
2993
2994 heap_free(bitmap->prop_item);
2995 bitmap->prop_item = prop_item;
2996 bitmap->prop_count++;
2997 }
2998
2999 static BOOL get_bool_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3000 {
3001 HRESULT hr;
3002 GUID format;
3003 PROPVARIANT id, value;
3004 BOOL ret = FALSE;
3005
3006 hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3007 if (FAILED(hr) || !IsEqualGUID(&format, guid)) return FALSE;
3008
3009 PropVariantInit(&id);
3010 PropVariantInit(&value);
3011
3012 id.vt = VT_LPWSTR;
3013 id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3014 if (!id.u.pwszVal) return FALSE;
3015 lstrcpyW(id.u.pwszVal, prop_name);
3016 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3017 if (hr == S_OK && value.vt == VT_BOOL)
3018 ret = value.u.boolVal;
3019
3020 PropVariantClear(&id);
3021 PropVariantClear(&value);
3022
3023 return ret;
3024 }
3025
3026 static PropertyItem *get_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3027 {
3028 HRESULT hr;
3029 GUID format;
3030 PROPVARIANT id, value;
3031 PropertyItem *item = NULL;
3032
3033 hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3034 if (FAILED(hr) || !IsEqualGUID(&format, guid)) return NULL;
3035
3036 PropVariantInit(&id);
3037 PropVariantInit(&value);
3038
3039 id.vt = VT_LPWSTR;
3040 id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3041 if (!id.u.pwszVal) return NULL;
3042 lstrcpyW(id.u.pwszVal, prop_name);
3043 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3044 if (hr == S_OK)
3045 {
3046 UINT item_size = propvariant_size(&value);
3047 if (item_size)
3048 {
3049 item_size += sizeof(*item);
3050 item = heap_alloc_zero(item_size);
3051 if (propvariant_to_item(&value, item, item_size, 0) != Ok)
3052 {
3053 heap_free(item);
3054 item = NULL;
3055 }
3056 }
3057 }
3058
3059 PropVariantClear(&id);
3060 PropVariantClear(&value);
3061
3062 return item;
3063 }
3064
3065 static PropertyItem *get_gif_comment(IWICMetadataReader *reader)
3066 {
3067 static const WCHAR textentryW[] = { 'T','e','x','t','E','n','t','r','y',0 };
3068 PropertyItem *comment;
3069
3070 comment = get_property(reader, &GUID_MetadataFormatGifComment, textentryW);
3071 if (comment)
3072 comment->id = PropertyTagExifUserComment;
3073
3074 return comment;
3075 }
3076
3077 static PropertyItem *get_gif_loopcount(IWICMetadataReader *reader)
3078 {
3079 static const WCHAR applicationW[] = { 'A','p','p','l','i','c','a','t','i','o','n',0 };
3080 static const WCHAR dataW[] = { 'D','a','t','a',0 };
3081 PropertyItem *appext = NULL, *appdata = NULL, *loop = NULL;
3082
3083 appext = get_property(reader, &GUID_MetadataFormatAPE, applicationW);
3084 if (appext)
3085 {
3086 if (appext->type == PropertyTagTypeByte && appext->length == 11 &&
3087 (!memcmp(appext->value, "NETSCAPE2.0", 11) || !memcmp(appext->value, "ANIMEXTS1.0", 11)))
3088 {
3089 appdata = get_property(reader, &GUID_MetadataFormatAPE, dataW);
3090 if (appdata)
3091 {
3092 if (appdata->type == PropertyTagTypeByte && appdata->length == 4)
3093 {
3094 BYTE *data = appdata->value;
3095 if (data[0] == 3 && data[1] == 1)
3096 {
3097 loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
3098 if (loop)
3099 {
3100 loop->type = PropertyTagTypeShort;
3101 loop->id = PropertyTagLoopCount;
3102 loop->length = sizeof(SHORT);
3103 loop->value = loop + 1;
3104 *(SHORT *)loop->value = data[2] | (data[3] << 8);
3105 }
3106 }
3107 }
3108 }
3109 }
3110 }
3111
3112 heap_free(appext);
3113 heap_free(appdata);
3114
3115 return loop;
3116 }
3117
3118 static PropertyItem *get_gif_background(IWICMetadataReader *reader)
3119 {
3120 static const WCHAR backgroundW[] = { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 };
3121 PropertyItem *background;
3122
3123 background = get_property(reader, &GUID_MetadataFormatLSD, backgroundW);
3124 if (background)
3125 background->id = PropertyTagIndexBackground;
3126
3127 return background;
3128 }
3129
3130 static PropertyItem *get_gif_palette(IWICBitmapDecoder *decoder, IWICMetadataReader *reader)
3131 {
3132 static const WCHAR global_flagW[] = { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 };
3133 HRESULT hr;
3134 IWICImagingFactory *factory;
3135 IWICPalette *palette;
3136 UINT count = 0;
3137 WICColor colors[256];
3138
3139 if (!get_bool_property(reader, &GUID_MetadataFormatLSD, global_flagW))
3140 return NULL;
3141
3142 hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
3143 if (hr != S_OK) return NULL;
3144
3145 hr = IWICImagingFactory_CreatePalette(factory, &palette);
3146 if (hr == S_OK)
3147 {
3148 hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
3149 if (hr == S_OK)
3150 IWICPalette_GetColors(palette, 256, colors, &count);
3151
3152 IWICPalette_Release(palette);
3153 }
3154
3155 IWICImagingFactory_Release(factory);
3156
3157 if (count)
3158 {
3159 PropertyItem *pal;
3160 UINT i;
3161 BYTE *rgb;
3162
3163 pal = heap_alloc_zero(sizeof(*pal) + count * 3);
3164 if (!pal) return NULL;
3165 pal->type = PropertyTagTypeByte;
3166 pal->id = PropertyTagGlobalPalette;
3167 pal->value = pal + 1;
3168 pal->length = count * 3;
3169
3170 rgb = pal->value;
3171
3172 for (i = 0; i < count; i++)
3173 {
3174 rgb[i*3] = (colors[i] >> 16) & 0xff;
3175 rgb[i*3 + 1] = (colors[i] >> 8) & 0xff;
3176 rgb[i*3 + 2] = colors[i] & 0xff;
3177 }
3178
3179 return pal;
3180 }
3181
3182 return NULL;
3183 }
3184
3185 static PropertyItem *get_gif_transparent_idx(IWICMetadataReader *reader)
3186 {
3187 static const WCHAR transparency_flagW[] = { 'T','r','a','n','s','p','a','r','e','n','c','y','F','l','a','g',0 };
3188 static const WCHAR colorW[] = { 'T','r','a','n','s','p','a','r','e','n','t','C','o','l','o','r','I','n','d','e','x',0 };
3189 PropertyItem *index = NULL;
3190
3191 if (get_bool_property(reader, &GUID_MetadataFormatGCE, transparency_flagW))
3192 {
3193 index = get_property(reader, &GUID_MetadataFormatGCE, colorW);
3194 if (index)
3195 index->id = PropertyTagIndexTransparent;
3196 }
3197 return index;
3198 }
3199
3200 static LONG get_gif_frame_property(IWICBitmapFrameDecode *frame, const GUID *format, const WCHAR *property)
3201 {
3202 HRESULT hr;
3203 IWICMetadataBlockReader *block_reader;
3204 IWICMetadataReader *reader;
3205 UINT block_count, i;
3206 PropertyItem *prop;
3207 LONG value = 0;
3208
3209 hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3210 if (hr == S_OK)
3211 {
3212 hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3213 if (hr == S_OK)
3214 {
3215 for (i = 0; i < block_count; i++)
3216 {
3217 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3218 if (hr == S_OK)
3219 {
3220 prop = get_property(reader, format, property);
3221 if (prop)
3222 {
3223 if (prop->type == PropertyTagTypeByte && prop->length == 1)
3224 value = *(BYTE *)prop->value;
3225 else if (prop->type == PropertyTagTypeShort && prop->length == 2)
3226 value = *(SHORT *)prop->value;
3227
3228 heap_free(prop);
3229 }
3230 IWICMetadataReader_Release(reader);
3231 }
3232 }
3233 }
3234 IWICMetadataBlockReader_Release(block_reader);
3235 }
3236
3237 return value;
3238 }
3239
3240 static void gif_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
3241 {
3242 static const WCHAR delayW[] = { 'D','e','l','a','y',0 };
3243 HRESULT hr;
3244 IWICBitmapFrameDecode *frame;
3245 IWICMetadataBlockReader *block_reader;
3246 IWICMetadataReader *reader;
3247 UINT frame_count, block_count, i;
3248 PropertyItem *delay = NULL, *comment = NULL, *background = NULL;
3249 PropertyItem *transparent_idx = NULL, *loop = NULL, *palette = NULL;
3250
3251 IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3252 if (frame_count > 1)
3253 {
3254 delay = heap_alloc_zero(sizeof(*delay) + frame_count * sizeof(LONG));
3255 if (delay)
3256 {
3257 LONG *value;
3258
3259 delay->type = PropertyTagTypeLong;
3260 delay->id = PropertyTagFrameDelay;
3261 delay->length = frame_count * sizeof(LONG);
3262 delay->value = delay + 1;
3263
3264 value = delay->value;
3265
3266 for (i = 0; i < frame_count; i++)
3267 {
3268 hr = IWICBitmapDecoder_GetFrame(decoder, i, &frame);
3269 if (hr == S_OK)
3270 {
3271 value[i] = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, delayW);
3272 IWICBitmapFrameDecode_Release(frame);
3273 }
3274 else value[i] = 0;
3275 }
3276 }
3277 }
3278
3279 hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3280 if (hr == S_OK)
3281 {
3282 hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3283 if (hr == S_OK)
3284 {
3285 for (i = 0; i < block_count; i++)
3286 {
3287 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3288 if (hr == S_OK)
3289 {
3290 if (!comment)
3291 comment = get_gif_comment(reader);
3292
3293 if (frame_count > 1 && !loop)
3294 loop = get_gif_loopcount(reader);
3295
3296 if (!background)
3297 background = get_gif_background(reader);
3298
3299 if (!palette)
3300 palette = get_gif_palette(decoder, reader);
3301
3302 IWICMetadataReader_Release(reader);
3303 }
3304 }
3305 }
3306 IWICMetadataBlockReader_Release(block_reader);
3307 }
3308
3309 if (frame_count > 1 && !loop)
3310 {
3311 loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
3312 if (loop)
3313 {
3314 loop->type = PropertyTagTypeShort;
3315 loop->id = PropertyTagLoopCount;
3316 loop->length = sizeof(SHORT);
3317 loop->value = loop + 1;
3318 *(SHORT *)loop->value = 1;
3319 }
3320 }
3321
3322 if (delay) add_property(bitmap, delay);
3323 if (comment) add_property(bitmap, comment);
3324 if (loop) add_property(bitmap, loop);
3325 if (palette) add_property(bitmap, palette);
3326 if (background) add_property(bitmap, background);
3327
3328 heap_free(delay);
3329 heap_free(comment);
3330 heap_free(loop);
3331 heap_free(palette);
3332 heap_free(background);
3333
3334 /* Win7 gdiplus always returns transparent color index from frame 0 */
3335 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
3336 if (hr != S_OK) return;
3337
3338 hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3339 if (hr == S_OK)
3340 {
3341 hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3342 if (hr == S_OK)
3343 {
3344 for (i = 0; i < block_count; i++)
3345 {
3346 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3347 if (hr == S_OK)
3348 {
3349 if (!transparent_idx)
3350 transparent_idx = get_gif_transparent_idx(reader);
3351
3352 IWICMetadataReader_Release(reader);
3353 }
3354 }
3355 }
3356 IWICMetadataBlockReader_Release(block_reader);
3357 }
3358
3359 if (transparent_idx) add_property(bitmap, transparent_idx);
3360 heap_free(transparent_idx);
3361
3362 IWICBitmapFrameDecode_Release(frame);
3363 }
3364
3365 static PropertyItem* create_prop(PROPID propid, PROPVARIANT* value)
3366 {
3367 PropertyItem *item = NULL;
3368 UINT item_size = propvariant_size(value);
3369
3370 if (item_size)
3371 {
3372 item_size += sizeof(*item);
3373 item = heap_alloc_zero(item_size);
3374 if (propvariant_to_item(value, item, item_size, propid) != Ok)
3375 {
3376 heap_free(item);
3377 item = NULL;
3378 }
3379 }
3380
3381 return item;
3382 }
3383
3384 static ULONG get_ulong_by_index(IWICMetadataReader* reader, ULONG index)
3385 {
3386 PROPVARIANT value;
3387 HRESULT hr;
3388 ULONG result=0;
3389
3390 hr = IWICMetadataReader_GetValueByIndex(reader, index, NULL, NULL, &value);
3391 if (SUCCEEDED(hr))
3392 {
3393 switch (value.vt)
3394 {
3395 case VT_UI4:
3396 result = value.u.ulVal;
3397 break;
3398 default:
3399 ERR("unhandled case %u\n", value.vt);
3400 break;
3401 }
3402 PropVariantClear(&value);
3403 }
3404 return result;
3405 }
3406
3407 static void png_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
3408 {
3409 HRESULT hr;
3410 IWICBitmapFrameDecode *frame;
3411 IWICMetadataBlockReader *block_reader;
3412 IWICMetadataReader *reader;
3413 UINT block_count, i, j;
3414 struct keyword_info {
3415 const char* name;
3416 PROPID propid;
3417 BOOL seen;
3418 } keywords[] = {
3419 { "Title", PropertyTagImageTitle },
3420 { "Author", PropertyTagArtist },
3421 { "Description", PropertyTagImageDescription },
3422 { "Copyright", PropertyTagCopyright },
3423 { "Software", PropertyTagSoftwareUsed },
3424 { "Source", PropertyTagEquipModel },
3425 { "Comment", PropertyTagExifUserComment },
3426 };
3427 BOOL seen_gamma=FALSE, seen_whitepoint=FALSE, seen_chrm=FALSE;
3428
3429 hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
3430 if (hr != S_OK) return;
3431
3432 hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3433 if (hr == S_OK)
3434 {
3435 hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3436 if (hr == S_OK)
3437 {
3438 for (i = 0; i < block_count; i++)
3439 {
3440 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3441 if (hr == S_OK)
3442 {
3443 GUID format;
3444
3445 hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3446 if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunktEXt, &format))
3447 {
3448 PROPVARIANT name, value;
3449 PropertyItem* item;
3450
3451 hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &name, &value);
3452
3453 if (SUCCEEDED(hr))
3454 {
3455 if (name.vt == VT_LPSTR)
3456 {
3457 for (j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++)
3458 if (!strcmp(keywords[j].name, name.u.pszVal))
3459 break;
3460 if (j < sizeof(keywords)/sizeof(keywords[0]) && !keywords[j].seen)
3461 {
3462 keywords[j].seen = TRUE;
3463 item = create_prop(keywords[j].propid, &value);
3464 if (item)
3465 add_property(bitmap, item);
3466 heap_free(item);
3467 }
3468 }
3469
3470 PropVariantClear(&name);
3471 PropVariantClear(&value);
3472 }
3473 }
3474 else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkgAMA, &format))
3475 {
3476 PropertyItem* item;
3477
3478 if (!seen_gamma)
3479 {
3480 item = heap_alloc_zero(sizeof(PropertyItem) + sizeof(ULONG) * 2);
3481 if (item)
3482 {
3483 ULONG *rational;
3484 item->length = sizeof(ULONG) * 2;
3485 item->type = PropertyTagTypeRational;
3486 item->id = PropertyTagGamma;
3487 rational = item->value = item + 1;
3488 rational[0] = 100000;
3489 rational[1] = get_ulong_by_index(reader, 0);
3490 add_property(bitmap, item);
3491 seen_gamma = TRUE;
3492 heap_free(item);
3493 }
3494 }
3495 }
3496 else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkcHRM, &format))
3497 {
3498 PropertyItem* item;
3499
3500 if (!seen_whitepoint)
3501 {
3502 item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 4);
3503 if (item)
3504 {
3505 ULONG *rational;
3506 item->length = sizeof(ULONG) * 4;
3507 item->type = PropertyTagTypeRational;
3508 item->id = PropertyTagWhitePoint;
3509 rational = item->value = item + 1;
3510 rational[0] = get_ulong_by_index(reader, 0);
3511 rational[1] = 100000;
3512 rational[2] = get_ulong_by_index(reader, 1);
3513 rational[3] = 100000;
3514 add_property(bitmap, item);
3515 seen_whitepoint = TRUE;
3516 GdipFree(item);
3517 }
3518 }
3519 if (!seen_chrm)
3520 {
3521 item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 12);
3522 if (item)
3523 {
3524 ULONG *rational;
3525 item->length = sizeof(ULONG) * 12;
3526 item->type = PropertyTagTypeRational;
3527 item->id = PropertyTagPrimaryChromaticities;
3528 rational = item->value = item + 1;
3529 rational[0] = get_ulong_by_index(reader, 2);
3530 rational[1] = 100000;
3531 rational[2] = get_ulong_by_index(reader, 3);
3532 rational[3] = 100000;
3533 rational[4] = get_ulong_by_index(reader, 4);
3534 rational[5] = 100000;
3535 rational[6] = get_ulong_by_index(reader, 5);
3536 rational[7] = 100000;
3537 rational[8] = get_ulong_by_index(reader, 6);
3538 rational[9] = 100000;
3539 rational[10] = get_ulong_by_index(reader, 7);
3540 rational[11] = 100000;
3541 add_property(bitmap, item);
3542 seen_chrm = TRUE;
3543 GdipFree(item);
3544 }
3545 }
3546 }
3547
3548 IWICMetadataReader_Release(reader);
3549 }
3550 }
3551 }
3552 IWICMetadataBlockReader_Release(block_reader);
3553 }
3554
3555 IWICBitmapFrameDecode_Release(frame);
3556 }
3557
3558 static GpStatus initialize_decoder_wic(IStream *stream, REFGUID container, IWICBitmapDecoder **decoder)
3559 {
3560 IWICImagingFactory *factory;
3561 HRESULT hr;
3562
3563 TRACE("%p,%s\n", stream, wine_dbgstr_guid(container));
3564
3565 hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
3566 if (FAILED(hr)) return hresult_to_status(hr);
3567 hr = IWICImagingFactory_CreateDecoder(factory, container, NULL, decoder);
3568 IWICImagingFactory_Release(factory);
3569 if (FAILED(hr)) return hresult_to_status(hr);
3570
3571 hr = IWICBitmapDecoder_Initialize(*decoder, stream, WICDecodeMetadataCacheOnLoad);
3572 if (FAILED(hr)) return hresult_to_status(hr);
3573 return Ok;
3574 }
3575
3576 typedef void (*metadata_reader_func)(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT frame);
3577
3578 static GpStatus decode_frame_wic(IWICBitmapDecoder *decoder, BOOL force_conversion,
3579 UINT active_frame, metadata_reader_func metadata_reader, GpImage **image)
3580 {
3581 GpStatus status=Ok;
3582 GpBitmap *bitmap;
3583 HRESULT hr;
3584 IWICBitmapFrameDecode *frame;
3585 IWICBitmapSource *source=NULL;
3586 IWICMetadataBlockReader *block_reader;
3587 WICPixelFormatGUID wic_format;
3588 PixelFormat gdip_format=0;
3589 ColorPalette *palette = NULL;
3590 WICBitmapPaletteType palette_type = WICBitmapPaletteTypeFixedHalftone256;
3591 int i;
3592 UINT width, height, frame_count;
3593 BitmapData lockeddata;
3594 WICRect wrc;
3595
3596 TRACE("%p,%u,%p\n", decoder, active_frame, image);
3597
3598 IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3599 hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
3600 if (SUCCEEDED(hr)) /* got frame */
3601 {
3602 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
3603
3604 if (SUCCEEDED(hr))
3605 {
3606 if (!force_conversion)
3607 {
3608 for (i=0; pixel_formats[i].wic_format; i++)
3609 {
3610 if (IsEqualGUID(&wic_format, pixel_formats[i].wic_format))
3611 {
3612 source = (IWICBitmapSource*)frame;
3613 IWICBitmapSource_AddRef(source);
3614 gdip_format = pixel_formats[i].gdip_format;
3615 palette_type = pixel_formats[i].palette_type;
3616 break;
3617 }
3618 }
3619 }
3620 if (!source)
3621 {
3622 /* unknown format; fall back on 32bppARGB */
3623 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
3624 gdip_format = PixelFormat32bppARGB;
3625 }
3626 TRACE("%s => %#x\n", wine_dbgstr_guid(&wic_format), gdip_format);
3627 }
3628
3629 if (SUCCEEDED(hr)) /* got source */
3630 {
3631 hr = IWICBitmapSource_GetSize(source, &width, &height);
3632
3633 if (SUCCEEDED(hr))
3634 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
3635 NULL, &bitmap);
3636
3637 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
3638 {
3639 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
3640 gdip_format, &lockeddata);
3641 if (status == Ok) /* locked bitmap */
3642 {
3643 wrc.X = 0;
3644 wrc.Width = width;
3645 wrc.Height = 1;
3646 for (i=0; i<height; i++)
3647 {
3648 wrc.Y = i;
3649 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
3650 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
3651 if (FAILED(hr)) break;
3652 }
3653
3654 GdipBitmapUnlockBits(bitmap, &lockeddata);
3655 }
3656
3657 if (SUCCEEDED(hr) && status == Ok)
3658 *image = &bitmap->image;
3659 else
3660 {
3661 *image = NULL;
3662 GdipDisposeImage(&bitmap->image);
3663 }
3664
3665 if (SUCCEEDED(hr) && status == Ok)
3666 {
3667 double dpix, dpiy;
3668 hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
3669 if (SUCCEEDED(hr))
3670 {
3671 bitmap->image.xres = dpix;
3672 bitmap->image.yres = dpiy;
3673 }
3674 hr = S_OK;
3675 }
3676 }
3677
3678 IWICBitmapSource_Release(source);
3679 }
3680
3681 if (SUCCEEDED(hr)) {
3682 bitmap->metadata_reader = NULL;
3683
3684 if (metadata_reader)
3685 metadata_reader(bitmap, decoder, active_frame);
3686 else if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
3687 {
3688 UINT block_count = 0;
3689 if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
3690 IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
3691 IWICMetadataBlockReader_Release(block_reader);
3692 }
3693
3694 palette = get_palette(frame, palette_type);
3695 IWICBitmapFrameDecode_Release(frame);
3696 }
3697 }
3698
3699 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
3700
3701 if (status == Ok)
3702 {
3703 /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
3704 bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI;
3705 if (IsEqualGUID(&wic_format, &GUID_WICPixelFormat2bppGray) ||
3706 IsEqualGUID(&wic_format, &GUID_WICPixelFormat4bppGray) ||
3707 IsEqualGUID(&wic_format, &GUID_WICPixelFormat8bppGray) ||
3708 IsEqualGUID(&wic_format, &GUID_WICPixelFormat16bppGray))
3709 bitmap->image.flags |= ImageFlagsColorSpaceGRAY;
3710 else
3711 bitmap->image.flags |= ImageFlagsColorSpaceRGB;
3712 bitmap->image.frame_count = frame_count;
3713 bitmap->image.current_frame = active_frame;
3714 bitmap->image.decoder = decoder;
3715 IWICBitmapDecoder_AddRef(decoder);
3716 if (palette)
3717 {
3718 heap_free(bitmap->image.palette);
3719 bitmap->image.palette = palette;
3720 }
3721 else
3722 {
3723 if (IsEqualGUID(&wic_format, &GUID_WICPixelFormatBlackWhite))
3724 bitmap->image.palette->Flags = 0;
3725 }
3726 TRACE("=> %p\n", *image);
3727 }
3728
3729 return status;
3730 }
3731
3732 static GpStatus decode_image_wic(IStream *stream, REFGUID container,
3733 metadata_reader_func metadata_reader, GpImage **image)
3734 {
3735 IWICBitmapDecoder *decoder;
3736 GpStatus status;
3737
3738 status = initialize_decoder_wic(stream, container, &decoder);
3739 if(status != Ok)
3740 return status;
3741
3742 status = decode_frame_wic(decoder, FALSE, 0, metadata_reader, image);
3743 IWICBitmapDecoder_Release(decoder);
3744 return status;
3745 }
3746
3747 static GpStatus select_frame_wic(GpImage *image, UINT active_frame)
3748 {
3749 GpImage *new_image;
3750 GpStatus status;
3751
3752 status = decode_frame_wic(image->decoder, FALSE, active_frame, NULL, &new_image);
3753 if(status != Ok)
3754 return status;
3755
3756 new_image->busy = image->busy;
3757 memcpy(&new_image->format, &image->format, sizeof(GUID));
3758 free_image_data(image);
3759 if (image->type == ImageTypeBitmap)
3760 *(GpBitmap *)image = *(GpBitmap *)new_image;
3761 else if (image->type == ImageTypeMetafile)
3762 *(GpMetafile *)image = *(GpMetafile *)new_image;
3763 new_image->type = ~0;
3764 heap_free(new_image);
3765 return Ok;
3766 }
3767
3768 static HRESULT get_gif_frame_rect(IWICBitmapFrameDecode *frame,
3769 UINT *left, UINT *top, UINT *width, UINT *height)
3770 {
3771 static const WCHAR leftW[] = {'L','e','f','t',0};
3772 static const WCHAR topW[] = {'T','o','p',0};
3773
3774 *left = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, leftW);
3775 *top = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, topW);
3776
3777 return IWICBitmapFrameDecode_GetSize(frame, width, height);
3778 }
3779
3780 static HRESULT blit_gif_frame(GpBitmap *bitmap, IWICBitmapFrameDecode *frame, BOOL first_frame)
3781 {
3782 UINT i, j, left, top, width, height;
3783 IWICBitmapSource *source;
3784 BYTE *new_bits;
3785 HRESULT hr;
3786
3787 hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
3788 if(FAILED(hr))
3789 return hr;
3790
3791 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
3792 if(FAILED(hr))
3793 return hr;
3794
3795 new_bits = heap_alloc_zero(width*height*4);
3796 if(!new_bits)
3797 return E_OUTOFMEMORY;
3798
3799 hr = IWICBitmapSource_CopyPixels(source, NULL, width*4, width*height*4, new_bits);
3800 IWICBitmapSource_Release(source);
3801 if(FAILED(hr)) {
3802 heap_free(new_bits);
3803 return hr;
3804 }
3805
3806 for(i=0; i<height && i+top<bitmap->height; i++) {
3807 for(j=0; j<width && j+left<bitmap->width; j++) {
3808 DWORD *src = (DWORD*)(new_bits+i*width*4+j*4);
3809 DWORD *dst = (DWORD*)(bitmap->bits+(i+top)*bitmap->stride+(j+left)*4);
3810
3811 if(first_frame || *src>>24 != 0)
3812 *dst = *src;
3813 }
3814 }
3815 heap_free(new_bits);
3816 return hr;
3817 }
3818
3819 static DWORD get_gif_background_color(GpBitmap *bitmap)
3820 {
3821 BYTE bgcolor_idx = 0;
3822 UINT i;
3823
3824 for(i=0; i<bitmap->prop_count; i++) {
3825 if(bitmap->prop_item[i].id == PropertyTagIndexBackground) {
3826 bgcolor_idx = *(BYTE*)bitmap->prop_item[i].value;
3827 break;
3828 }
3829 }
3830
3831 for(i=0; i<bitmap->prop_count; i++) {
3832 if(bitmap->prop_item[i].id == PropertyTagIndexTransparent) {
3833 BYTE transparent_idx;
3834 transparent_idx = *(BYTE*)bitmap->prop_item[i].value;
3835
3836 if(transparent_idx == bgcolor_idx)
3837 return 0;
3838 }
3839 }
3840
3841 for(i=0; i<bitmap->prop_count; i++) {
3842 if(bitmap->prop_item[i].id == PropertyTagGlobalPalette) {
3843 if(bitmap->prop_item[i].length/3 > bgcolor_idx) {
3844 BYTE *color = ((BYTE*)bitmap->prop_item[i].value)+bgcolor_idx*3;
3845 return color[2] + (color[1]<<8) + (color[0]<<16) + (0xffu<<24);
3846 }
3847 break;
3848 }
3849 }
3850
3851 FIXME("can't get gif background color\n");
3852 return 0xffffffff;
3853 }
3854
3855 static GpStatus select_frame_gif(GpImage* image, UINT active_frame)
3856 {
3857 static const WCHAR disposalW[] = {'D','i','s','p','o','s','a','l',0};
3858
3859 GpBitmap *bitmap = (GpBitmap*)image;
3860 IWICBitmapFrameDecode *frame;
3861 int cur_frame=0, disposal;
3862 BOOL bgcolor_set = FALSE;
3863 DWORD bgcolor = 0;
3864 HRESULT hr;
3865
3866 if(active_frame > image->current_frame) {
3867 hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, image->current_frame, &frame);
3868 if(FAILED(hr))
3869 return hresult_to_status(hr);
3870 disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
3871 IWICBitmapFrameDecode_Release(frame);
3872
3873 if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND)
3874 cur_frame = image->current_frame;
3875 else if(disposal != GIF_DISPOSE_RESTORE_TO_PREV)
3876 cur_frame = image->current_frame+1;
3877 }
3878
3879 while(cur_frame != active_frame) {
3880 hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, cur_frame, &frame);
3881 if(FAILED(hr))
3882 return hresult_to_status(hr);
3883 disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
3884
3885 if(disposal==GIF_DISPOSE_UNSPECIFIED || disposal==GIF_DISPOSE_DO_NOT_DISPOSE) {
3886 hr = blit_gif_frame(bitmap, frame, cur_frame==0);
3887 if(FAILED(hr))
3888 return hresult_to_status(hr);
3889 }else if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND) {
3890 UINT left, top, width, height, i, j;
3891
3892 if(!bgcolor_set) {
3893 bgcolor = get_gif_background_color(bitmap);
3894 bgcolor_set = TRUE;
3895 }
3896
3897 hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
3898 if(FAILED(hr))
3899 return hresult_to_status(hr);
3900 for(i=top; i<top+height && i<bitmap->height; i++) {
3901 DWORD *bits = (DWORD*)(bitmap->bits+i*bitmap->stride);
3902 for(j=left; j<left+width && j<bitmap->width; j++)
3903 bits[j] = bgcolor;
3904 }
3905 }
3906
3907 IWICBitmapFrameDecode_Release(frame);
3908 cur_frame++;
3909 }
3910
3911 hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, active_frame, &frame);
3912 if(FAILED(hr))
3913 return hresult_to_status(hr);
3914
3915 hr = blit_gif_frame(bitmap, frame, cur_frame==0);
3916 IWICBitmapFrameDecode_Release(frame);
3917 if(FAILED(hr))
3918 return hresult_to_status(hr);
3919
3920 image->current_frame = active_frame;
3921 return Ok;
3922 }
3923
3924 static GpStatus decode_image_icon(IStream* stream, GpImage **image)
3925 {
3926 return decode_image_wic(stream, &GUID_ContainerFormatIco, NULL, image);
3927 }
3928
3929 static GpStatus decode_image_bmp(IStream* stream, GpImage **image)
3930 {
3931 GpStatus status;
3932 GpBitmap* bitmap;
3933
3934 status = decode_image_wic(stream, &GUID_ContainerFormatBmp, NULL, image);
3935
3936 bitmap = (GpBitmap*)*image;
3937
3938 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
3939 {
3940 /* WIC supports bmp files with alpha, but gdiplus does not */
3941 bitmap->format = PixelFormat32bppRGB;
3942 }
3943
3944 return status;
3945 }
3946
3947 static GpStatus decode_image_jpeg(IStream* stream, GpImage **image)
3948 {
3949 return decode_image_wic(stream, &GUID_ContainerFormatJpeg, NULL, image);
3950 }
3951
3952 static GpStatus decode_image_png(IStream* stream, GpImage **image)
3953 {
3954 IWICBitmapDecoder *decoder;
3955 IWICBitmapFrameDecode *frame;
3956 GpStatus status;
3957 HRESULT hr;
3958 GUID format;
3959 BOOL force_conversion = FALSE;
3960
3961 status = initialize_decoder_wic(stream, &GUID_ContainerFormatPng, &decoder);
3962 if (status != Ok)
3963 return status;
3964
3965 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
3966 if (hr == S_OK)
3967 {
3968 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
3969 if (hr == S_OK)
3970 {
3971 if (IsEqualGUID(&format, &GUID_WICPixelFormat8bppGray))
3972 force_conversion = TRUE;
3973 status = decode_frame_wic(decoder, force_conversion, 0, png_metadata_reader, image);
3974 }
3975 else
3976 status = hresult_to_status(hr);
3977
3978 IWICBitmapFrameDecode_Release(frame);
3979 }
3980 else
3981 status = hresult_to_status(hr);
3982
3983 IWICBitmapDecoder_Release(decoder);
3984 return status;
3985 }
3986
3987 static GpStatus decode_image_gif(IStream* stream, GpImage **image)
3988 {
3989 IWICBitmapDecoder *decoder;
3990 UINT frame_count;
3991 GpStatus status;
3992 HRESULT hr;
3993
3994 status = initialize_decoder_wic(stream, &GUID_ContainerFormatGif, &decoder);
3995 if(status != Ok)
3996 return status;
3997
3998 hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3999 if(FAILED(hr))
4000 return hresult_to_status(hr);
4001
4002 status = decode_frame_wic(decoder, frame_count > 1, 0, gif_metadata_reader, image);
4003 IWICBitmapDecoder_Release(decoder);
4004 if(status != Ok)
4005 return status;
4006
4007 if(frame_count > 1) {
4008 heap_free((*image)->palette);
4009 (*image)->palette = NULL;
4010 }
4011 return Ok;
4012 }
4013
4014 static GpStatus decode_image_tiff(IStream* stream, GpImage **image)
4015 {
4016 return decode_image_wic(stream, &GUID_ContainerFormatTiff, NULL, image);
4017 }
4018
4019 static GpStatus load_wmf(IStream *stream, GpMetafile **metafile)
4020 {
4021 WmfPlaceableFileHeader pfh;
4022 BOOL is_placeable = FALSE;
4023 LARGE_INTEGER seek;
4024 GpStatus status;
4025 METAHEADER mh;
4026 HMETAFILE hmf;
4027 HRESULT hr;
4028 UINT size;
4029 void *buf;
4030
4031 hr = IStream_Read(stream, &mh, sizeof(mh), &size);
4032 if (hr != S_OK || size != sizeof(mh))
4033 return GenericError;
4034
4035 if (((WmfPlaceableFileHeader *)&mh)->Key == WMF_PLACEABLE_KEY)
4036 {
4037 seek.QuadPart = 0;
4038 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4039 if (FAILED(hr)) return hresult_to_status(hr);
4040
4041 hr = IStream_Read(stream, &pfh, sizeof(pfh), &size);
4042 if (hr != S_OK || size != sizeof(pfh))
4043 return GenericError;
4044
4045 hr = IStream_Read(stream, &mh, sizeof(mh), &size);
4046 if (hr != S_OK || size != sizeof(mh))
4047 return GenericError;
4048
4049 is_placeable = TRUE;
4050 }
4051
4052 seek.QuadPart = is_placeable ? sizeof(pfh) : 0;
4053 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4054 if (FAILED(hr)) return hresult_to_status(hr);
4055
4056 buf = heap_alloc(mh.mtSize * 2);
4057 if (!buf) return OutOfMemory;
4058
4059 hr = IStream_Read(stream, buf, mh.mtSize * 2, &size);
4060 if (hr != S_OK || size != mh.mtSize * 2)
4061 {
4062 heap_free(buf);
4063 return GenericError;
4064 }
4065
4066 hmf = SetMetaFileBitsEx(mh.mtSize * 2, buf);
4067 heap_free(buf);
4068 if (!hmf)
4069 return GenericError;
4070
4071 status = GdipCreateMetafileFromWmf(hmf, TRUE, is_placeable ? &pfh : NULL, metafile);
4072 if (status != Ok)
4073 DeleteMetaFile(hmf);
4074 return status;
4075 }
4076
4077 static GpStatus decode_image_wmf(IStream *stream, GpImage **image)
4078 {
4079 GpMetafile *metafile;
4080 GpStatus status;
4081
4082 TRACE("%p %p\n", stream, image);
4083
4084 if (!stream || !image)
4085 return InvalidParameter;
4086
4087 status = load_wmf(stream, &metafile);
4088 if (status != Ok)
4089 {
4090 TRACE("Could not load metafile\n");
4091 return status;
4092 }
4093
4094 *image = (GpImage *)metafile;
4095 TRACE("<-- %p\n", *image);
4096
4097 return Ok;
4098 }
4099
4100 static GpStatus load_emf(IStream *stream, GpMetafile **metafile)
4101 {
4102 LARGE_INTEGER seek;
4103 ENHMETAHEADER emh;
4104 HENHMETAFILE hemf;
4105 GpStatus status;
4106 HRESULT hr;
4107 UINT size;
4108 void *buf;
4109
4110 hr = IStream_Read(stream, &emh, sizeof(emh), &size);
4111 if (hr != S_OK || size != sizeof(emh) || emh.dSignature != ENHMETA_SIGNATURE)
4112 return GenericError;
4113
4114 seek.QuadPart = 0;
4115 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4116 if (FAILED(hr)) return hresult_to_status(hr);
4117
4118 buf = heap_alloc(emh.nBytes);
4119 if (!buf) return OutOfMemory;
4120
4121 hr = IStream_Read(stream, buf, emh.nBytes, &size);
4122 if (hr != S_OK || size != emh.nBytes)
4123 {
4124 heap_free(buf);
4125 return GenericError;
4126 }
4127
4128 hemf = SetEnhMetaFileBits(emh.nBytes, buf);
4129 heap_free(buf);
4130 if (!hemf)
4131 return GenericError;
4132
4133 status = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
4134 if (status != Ok)
4135 DeleteEnhMetaFile(hemf);
4136 return status;
4137 }
4138
4139 static GpStatus decode_image_emf(IStream *stream, GpImage **image)
4140 {
4141 GpMetafile *metafile;
4142 GpStatus status;
4143
4144 TRACE("%p %p\n", stream, image);
4145
4146 if (!stream || !image)
4147 return InvalidParameter;
4148
4149 status = load_emf(stream, &metafile);
4150 if (status != Ok)
4151 {
4152 TRACE("Could not load metafile\n");
4153 return status;
4154 }
4155
4156 *image = (GpImage *)metafile;
4157 TRACE("<-- %p\n", *image);
4158
4159 return Ok;
4160 }
4161
4162 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
4163 GDIPCONST EncoderParameters* params);
4164
4165 typedef GpStatus (*decode_image_func)(IStream *stream, GpImage **image);
4166
4167 typedef GpStatus (*select_image_func)(GpImage *image, UINT active_frame);
4168
4169 typedef struct image_codec {
4170 ImageCodecInfo info;
4171 encode_image_func encode_func;
4172 decode_image_func decode_func;
4173 select_image_func select_func;
4174 } image_codec;
4175
4176 typedef enum {
4177 BMP,
4178 JPEG,
4179 GIF,
4180 TIFF,
4181 EMF,
4182 WMF,
4183 PNG,
4184 ICO,
4185 NUM_CODECS
4186 } ImageFormat;
4187
4188 static const struct image_codec codecs[NUM_CODECS];
4189
4190 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
4191 {
4192 BYTE signature[8];
4193 const BYTE *pattern, *mask;
4194 LARGE_INTEGER seek;
4195 HRESULT hr;
4196 UINT bytesread;
4197 int i;
4198 DWORD j, sig;
4199
4200 /* seek to the start of the stream */
4201 seek.QuadPart = 0;
4202 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4203 if (FAILED(hr)) return hresult_to_status(hr);
4204
4205 /* read the first 8 bytes */
4206 /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
4207 hr = IStream_Read(stream, signature, 8, &bytesread);
4208 if (FAILED(hr)) return hresult_to_status(hr);
4209 if (hr == S_FALSE || bytesread == 0) return GenericError;
4210
4211 for (i = 0; i < NUM_CODECS; i++) {
4212 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
4213 bytesread >= codecs[i].info.SigSize)
4214 {
4215 for (sig=0; sig<codecs[i].info.SigCount; sig++)
4216 {
4217 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
4218 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
4219 for (j=0; j<codecs[i].info.SigSize; j++)
4220 if ((signature[j] & mask[j]) != pattern[j])
4221 break;
4222 if (j == codecs[i].info.SigSize)
4223 {
4224 *result = &codecs[i];
4225 return Ok;
4226 }
4227 }
4228 }
4229 }
4230
4231 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
4232 signature[0],signature[1],signature[2],signature[3],
4233 signature[4],signature[5],signature[6],signature[7]);
4234
4235 return GenericError;
4236 }
4237
4238 static GpStatus get_decoder_info_from_image(GpImage *image, const struct image_codec **result)
4239 {
4240 int i;
4241
4242 for (i = 0; i < NUM_CODECS; i++) {
4243 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
4244 IsEqualIID(&codecs[i].info.FormatID, &image->format))
4245 {
4246 *result = &codecs[i];
4247 return Ok;
4248 }
4249 }
4250
4251 TRACE("no match for format: %s\n", wine_dbgstr_guid(&image->format));
4252 return GenericError;
4253 }
4254
4255 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
4256 UINT frame)
4257 {
4258 GpStatus stat;
4259 const struct image_codec *codec = NULL;
4260 BOOL unlock;
4261
4262 TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
4263
4264 if (!image || !dimensionID)
4265 return InvalidParameter;
4266 if(!image_lock(image, &unlock))
4267 return ObjectBusy;
4268
4269 if (frame >= image->frame_count)
4270 {
4271 WARN("requested frame %u, but image has only %u\n", frame, image->frame_count);
4272 image_unlock(image, unlock);
4273 return InvalidParameter;
4274 }
4275
4276 if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
4277 {
4278 WARN("invalid image type %d\n", image->type);
4279 image_unlock(image, unlock);
4280 return InvalidParameter;
4281 }
4282
4283 if (image->current_frame == frame)
4284 {
4285 image_unlock(image, unlock);
4286 return Ok;
4287 }
4288
4289 if (!image->decoder)
4290 {
4291 TRACE("image doesn't have an associated decoder\n");
4292 image_unlock(image, unlock);
4293 return Ok;
4294 }
4295
4296 /* choose an appropriate image decoder */
4297 stat = get_decoder_info_from_image(image, &codec);
4298 if (stat != Ok)
4299 {
4300 WARN("can't find decoder info\n");
4301 image_unlock(image, unlock);
4302 return stat;
4303 }
4304
4305 stat = codec->select_func(image, frame);
4306 image_unlock(image, unlock);
4307 return stat;
4308 }
4309
4310 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
4311 {
4312 GpStatus stat;
4313 LARGE_INTEGER seek;
4314 HRESULT hr;
4315 const struct image_codec *codec=NULL;
4316
4317 /* choose an appropriate image decoder */
4318 stat = get_decoder_info(stream, &codec);
4319 if (stat != Ok) return stat;
4320
4321 /* seek to the start of the stream */
4322 seek.QuadPart = 0;
4323 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4324 if (FAILED(hr)) return hresult_to_status(hr);
4325
4326 /* call on the image decoder to do the real work */
4327 stat = codec->decode_func(stream, image);
4328
4329 /* take note of the original data format */
4330 if (stat == Ok)
4331 {
4332 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
4333 return Ok;
4334 }
4335
4336 return stat;
4337 }
4338
4339 /* FIXME: no ICM */
4340 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
4341 {
4342 TRACE("%p %p\n", stream, image);
4343
4344 return GdipLoadImageFromStream(stream, image);
4345 }
4346
4347 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
4348 {
4349 static int calls;
4350
4351 TRACE("(%p,%u)\n", image, propId);
4352
4353 if(!image)
4354 return InvalidParameter;
4355
4356 if(!(calls++))
4357 FIXME("not implemented\n");
4358
4359 return NotImplemented;
4360 }
4361
4362 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
4363 {
4364 static int calls;
4365
4366 if (!image || !item) return InvalidParameter;
4367
4368 TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
4369
4370 if(!(calls++))
4371 FIXME("not implemented\n");
4372
4373 return Ok;
4374 }
4375
4376 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
4377 GDIPCONST CLSID *clsidEncoder,
4378 GDIPCONST EncoderParameters *encoderParams)
4379 {
4380 GpStatus stat;
4381 IStream *stream;
4382
4383 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
4384
4385 if (!image || !filename|| !clsidEncoder)
4386 return InvalidParameter;
4387
4388 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
4389 if (stat != Ok)
4390 return GenericError;
4391
4392 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
4393
4394 IStream_Release(stream);
4395 return stat;
4396 }
4397
4398 /*************************************************************************
4399 * Encoding functions -
4400 * These functions encode an image in different image file formats.
4401 */
4402
4403 static GpStatus encode_image_wic(GpImage *image, IStream* stream,
4404 REFGUID container, GDIPCONST EncoderParameters* params)
4405 {
4406 GpStatus stat;
4407 GpBitmap *bitmap;
4408 IWICImagingFactory *factory;
4409 IWICBitmapEncoder *encoder;
4410 IWICBitmapFrameEncode *frameencode;
4411 IPropertyBag2 *encoderoptions;
4412 HRESULT hr;
4413 UINT width, height;
4414 PixelFormat gdipformat=0;
4415 const WICPixelFormatGUID *desired_wicformat;
4416 WICPixelFormatGUID wicformat;
4417 GpRect rc;
4418 BitmapData lockeddata;
4419 UINT i;
4420
4421 if (image->type != ImageTypeBitmap)
4422 return GenericError;
4423
4424 bitmap = (GpBitmap*)image;
4425
4426 GdipGetImageWidth(image, &width);
4427 GdipGetImageHeight(image, &height);
4428
4429 rc.X = 0;
4430 rc.Y = 0;
4431 rc.Width = width;
4432 rc.Height = height;
4433
4434 hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
4435 if (FAILED(hr))
4436 return hresult_to_status(hr);
4437 hr = IWICImagingFactory_CreateEncoder(factory, container, NULL, &encoder);
4438 IWICImagingFactory_Release(factory);
4439 if (FAILED(hr))
4440 return hresult_to_status(hr);
4441
4442 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
4443
4444 if (SUCCEEDED(hr))
4445 {
4446 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
4447 }
4448
4449 if (SUCCEEDED(hr)) /* created frame */
4450 {
4451 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
4452
4453 if (SUCCEEDED(hr))
4454 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
4455
4456 if (SUCCEEDED(hr))
4457 hr = IWICBitmapFrameEncode_SetResolution(frameencode, image->xres, image->yres);
4458
4459 if (SUCCEEDED(hr))
4460 {
4461 for (i=0; pixel_formats[i].wic_format; i++)
4462 {
4463 if (pixel_formats[i].gdip_format == bitmap->format)
4464 {
4465 desired_wicformat = pixel_formats[i].wic_format;
4466 gdipformat = bitmap->format;
4467 break;
4468 }
4469 }
4470 if (!gdipformat)
4471 {
4472 desired_wicformat = &GUID_WICPixelFormat32bppBGRA;
4473 gdipformat = PixelFormat32bppARGB;
4474 }
4475
4476 memcpy(&wicformat, desired_wicformat, sizeof(GUID));
4477 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
4478 }
4479
4480 if (SUCCEEDED(hr) && !IsEqualGUID(desired_wicformat, &wicformat))
4481 {
4482 /* Encoder doesn't support this bitmap's format. */
4483 gdipformat = 0;
4484 for (i=0; pixel_formats[i].wic_format; i++)
4485 {
4486 if (IsEqualGUID(&wicformat, pixel_formats[i].wic_format))
4487 {
4488 gdipformat = pixel_formats[i].gdip_format;
4489 break;
4490 }
4491 }
4492 if (!gdipformat)
4493 {
4494 ERR("Cannot support encoder format %s\n", debugstr_guid(&wicformat));
4495 hr = E_FAIL;
4496 }
4497 }
4498
4499 if (SUCCEEDED(hr))
4500 {
4501 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
4502 &lockeddata);
4503
4504 if (stat == Ok)
4505 {
4506 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
4507 BYTE *row;
4508
4509 /* write one row at a time in case stride is negative */
4510 row = lockeddata.Scan0;
4511 for (i=0; i<lockeddata.Height; i++)
4512 {
4513 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
4514 if (FAILED(hr)) break;
4515 row += lockeddata.Stride;
4516 }
4517
4518 GdipBitmapUnlockBits(bitmap, &lockeddata);
4519 }
4520 else
4521 hr = E_FAIL;
4522 }
4523
4524 if (SUCCEEDED(hr))
4525 hr = IWICBitmapFrameEncode_Commit(frameencode);
4526
4527 IWICBitmapFrameEncode_Release(frameencode);
4528 IPropertyBag2_Release(encoderoptions);
4529 }
4530
4531 if (SUCCEEDED(hr))
4532 hr = IWICBitmapEncoder_Commit(encoder);
4533
4534 IWICBitmapEncoder_Release(encoder);
4535 return hresult_to_status(hr);
4536 }
4537
4538 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
4539 GDIPCONST EncoderParameters* params)
4540 {
4541 return encode_image_wic(image, stream, &GUID_ContainerFormatBmp, params);
4542 }
4543
4544 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
4545 GDIPCONST EncoderParameters* params)
4546 {
4547 return encode_image_wic(image, stream, &GUID_ContainerFormatTiff, params);
4548 }
4549
4550 GpStatus encode_image_png(GpImage *image, IStream* stream,
4551 GDIPCONST EncoderParameters* params)
4552 {
4553 return encode_image_wic(image, stream, &GUID_ContainerFormatPng, params);
4554 }
4555
4556 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
4557 GDIPCONST EncoderParameters* params)
4558 {
4559 return encode_image_wic(image, stream, &GUID_ContainerFormatJpeg, params);
4560 }
4561
4562 static GpStatus encode_image_gif(GpImage *image, IStream* stream,
4563 GDIPCONST EncoderParameters* params)
4564 {
4565 return encode_image_wic(image, stream, &CLSID_WICGifEncoder, params);
4566 }
4567
4568 /*****************************************************************************
4569 * GdipSaveImageToStream [GDIPLUS.@]
4570 */
4571 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
4572 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
4573 {
4574 GpStatus stat;
4575 encode_image_func encode_image;
4576 int i;
4577
4578 TRACE("%p %p %p %p\n", image, stream, clsid, params);
4579
4580 if(!image || !stream)
4581 return InvalidParameter;
4582
4583 /* select correct encoder */
4584 encode_image = NULL;
4585 for (i = 0; i < NUM_CODECS; i++) {
4586 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
4587 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
4588 encode_image = codecs[i].encode_func;
4589 }
4590 if (encode_image == NULL)
4591 return UnknownImageFormat;
4592
4593 stat = encode_image(image, stream, params);
4594
4595 return stat;
4596 }
4597
4598 /*****************************************************************************
4599 * GdipSaveAdd [GDIPLUS.@]
4600 */
4601 GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
4602 {
4603 FIXME("(%p,%p): stub\n", image, params);
4604 return Ok;
4605 }
4606
4607 /*****************************************************************************
4608 * GdipGetImagePalette [GDIPLUS.@]
4609 */
4610 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
4611 {
4612 INT count;
4613
4614 TRACE("(%p,%p,%i)\n", image, palette, size);
4615
4616 if (!image || !palette)
4617 return InvalidParameter;
4618
4619 count = image->palette ? image->palette->Count : 0;
4620
4621 if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
4622 {
4623 TRACE("<-- InsufficientBuffer\n");
4624 return InsufficientBuffer;
4625 }
4626
4627 if (image->palette)
4628 {
4629 palette->Flags = image->palette->Flags;
4630 palette->Count = image->palette->Count;
4631 memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
4632 }
4633 else
4634 {
4635 palette->Flags = 0;
4636 palette->Count = 0;
4637 }
4638 return Ok;
4639 }
4640
4641 /*****************************************************************************
4642 * GdipSetImagePalette [GDIPLUS.@]
4643 */
4644 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
4645 GDIPCONST ColorPalette *palette)
4646 {
4647 ColorPalette *new_palette;
4648
4649 TRACE("(%p,%p)\n", image, palette);
4650
4651 if(!image || !palette || palette->Count > 256)
4652 return InvalidParameter;
4653
4654 new_palette = heap_alloc_zero(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
4655 if (!new_palette) return OutOfMemory;
4656
4657 heap_free(image->palette);
4658 image->palette = new_palette;
4659 image->palette->Flags = palette->Flags;
4660 image->palette->Count = palette->Count;
4661 memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
4662
4663 return Ok;
4664 }
4665
4666 /*************************************************************************
4667 * Encoders -
4668 * Structures that represent which formats we support for encoding.
4669 */
4670
4671 /* ImageCodecInfo creation routines taken from libgdiplus */
4672 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
4673 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
4674 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
4675 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
4676 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
4677 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
4678
4679 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
4680 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
4681 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
4682 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
4683 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
4684 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
4685
4686 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
4687 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
4688 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
4689 static const WCHAR gif_format[] = {'G','I','F',0};
4690 static const BYTE gif_sig_pattern[12] = "GIF87aGIF89a";
4691 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4692
4693 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
4694 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
4695 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
4696 static const WCHAR tiff_format[] = {'T','I','F','F',0};
4697 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
4698 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4699
4700 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
4701 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
4702 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
4703 static const WCHAR emf_format[] = {'E','M','F',0};
4704 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
4705 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
4706
4707 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
4708 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
4709 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
4710 static const WCHAR wmf_format[] = {'W','M','F',0};
4711 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
4712 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
4713
4714 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
4715 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
4716 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
4717 static const WCHAR png_format[] = {'P','N','G',0};
4718 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
4719 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4720
4721 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
4722 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
4723 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
4724 static const WCHAR ico_format[] = {'I','C','O',0};
4725 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
4726 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
4727
4728 static const struct image_codec codecs[NUM_CODECS] = {
4729 {
4730 { /* BMP */
4731 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4732 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4733 /* CodecName */ bmp_codecname,
4734 /* DllName */ NULL,
4735 /* FormatDescription */ bmp_format,
4736 /* FilenameExtension */ bmp_extension,
4737 /* MimeType */ bmp_mimetype,
4738 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4739 /* Version */ 1,
4740 /* SigCount */ 1,
4741 /* SigSize */ 2,
4742 /* SigPattern */ bmp_sig_pattern,
4743 /* SigMask */ bmp_sig_mask,
4744 },
4745 encode_image_BMP,
4746 decode_image_bmp,
4747 select_frame_wic
4748 },
4749 {
4750 { /* JPEG */
4751 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4752 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4753 /* CodecName */ jpeg_codecname,
4754 /* DllName */ NULL,
4755 /* FormatDescription */ jpeg_format,
4756 /* FilenameExtension */ jpeg_extension,
4757 /* MimeType */ jpeg_mimetype,
4758 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4759 /* Version */ 1,
4760 /* SigCount */ 1,
4761 /* SigSize */ 2,
4762 /* SigPattern */ jpeg_sig_pattern,
4763 /* SigMask */ jpeg_sig_mask,
4764 },
4765 encode_image_jpeg,
4766 decode_image_jpeg,
4767 select_frame_wic
4768 },
4769 {
4770 { /* GIF */
4771 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4772 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4773 /* CodecName */ gif_codecname,
4774 /* DllName */ NULL,
4775 /* FormatDescription */ gif_format,
4776 /* FilenameExtension */ gif_extension,
4777 /* MimeType */ gif_mimetype,
4778 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4779 /* Version */ 1,
4780 /* SigCount */ 2,
4781 /* SigSize */ 6,
4782 /* SigPattern */ gif_sig_pattern,
4783 /* SigMask */ gif_sig_mask,
4784 },
4785 encode_image_gif,
4786 decode_image_gif,
4787 select_frame_gif
4788 },
4789 {
4790 { /* TIFF */
4791 /* Clsid */ { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4792 /* FormatID */ { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4793 /* CodecName */ tiff_codecname,
4794 /* DllName */ NULL,
4795 /* FormatDescription */ tiff_format,
4796 /* FilenameExtension */ tiff_extension,
4797 /* MimeType */ tiff_mimetype,
4798 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4799 /* Version */ 1,
4800 /* SigCount */ 2,
4801 /* SigSize */ 4,
4802 /* SigPattern */ tiff_sig_pattern,
4803 /* SigMask */ tiff_sig_mask,
4804 },
4805 encode_image_tiff,
4806 decode_image_tiff,
4807 select_frame_wic
4808 },
4809 {
4810 { /* EMF */
4811 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4812 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4813 /* CodecName */ emf_codecname,
4814 /* DllName */ NULL,
4815 /* FormatDescription */ emf_format,
4816 /* FilenameExtension */ emf_extension,
4817 /* MimeType */ emf_mimetype,
4818 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
4819 /* Version */ 1,
4820 /* SigCount */ 1,
4821 /* SigSize */ 4,
4822 /* SigPattern */ emf_sig_pattern,
4823 /* SigMask */ emf_sig_mask,
4824 },
4825 NULL,
4826 decode_image_emf,
4827 NULL
4828 },
4829 {
4830 { /* WMF */
4831 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4832 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4833 /* CodecName */ wmf_codecname,
4834 /* DllName */ NULL,
4835 /* FormatDescription */ wmf_format,
4836 /* FilenameExtension */ wmf_extension,
4837 /* MimeType */ wmf_mimetype,
4838 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
4839 /* Version */ 1,
4840 /* SigCount */ 1,
4841 /* SigSize */ 2,
4842 /* SigPattern */ wmf_sig_pattern,
4843 /* SigMask */ wmf_sig_mask,
4844 },
4845 NULL,
4846 decode_image_wmf,
4847 NULL
4848 },
4849 {
4850 { /* PNG */
4851 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4852 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4853 /* CodecName */ png_codecname,
4854 /* DllName */ NULL,
4855 /* FormatDescription */ png_format,
4856 /* FilenameExtension */ png_extension,
4857 /* MimeType */ png_mimetype,
4858 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4859 /* Version */ 1,
4860 /* SigCount */ 1,
4861 /* SigSize */ 8,
4862 /* SigPattern */ png_sig_pattern,
4863 /* SigMask */ png_sig_mask,
4864 },
4865 encode_image_png,
4866 decode_image_png,
4867 select_frame_wic
4868 },
4869 {
4870 { /* ICO */
4871 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4872 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4873 /* CodecName */ ico_codecname,
4874 /* DllName */ NULL,
4875 /* FormatDescription */ ico_format,
4876 /* FilenameExtension */ ico_extension,
4877 /* MimeType */ ico_mimetype,
4878 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4879 /* Version */ 1,
4880 /* SigCount */ 1,
4881 /* SigSize */ 4,
4882 /* SigPattern */ ico_sig_pattern,
4883 /* SigMask */ ico_sig_mask,
4884 },
4885 NULL,
4886 decode_image_icon,
4887 select_frame_wic
4888 },
4889 };
4890
4891 /*****************************************************************************
4892 * GdipGetImageDecodersSize [GDIPLUS.@]
4893 */
4894 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
4895 {
4896 int decoder_count=0;
4897 int i;
4898 TRACE("%p %p\n", numDecoders, size);
4899
4900 if (!numDecoders || !size)
4901 return InvalidParameter;
4902
4903 for (i=0; i<NUM_CODECS; i++)
4904 {
4905 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
4906 decoder_count++;
4907 }
4908
4909 *numDecoders = decoder_count;
4910 *size = decoder_count * sizeof(ImageCodecInfo);
4911
4912 return Ok;
4913 }
4914
4915 /*****************************************************************************
4916 * GdipGetImageDecoders [GDIPLUS.@]
4917 */
4918 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
4919 {
4920 int i, decoder_count=0;
4921 TRACE("%u %u %p\n", numDecoders, size, decoders);
4922
4923 if (!decoders ||
4924 size != numDecoders * sizeof(ImageCodecInfo))
4925 return GenericError;
4926
4927 for (i=0; i<NUM_CODECS; i++)
4928 {
4929 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
4930 {
4931 if (decoder_count == numDecoders) return GenericError;
4932 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4933 decoder_count++;
4934 }
4935 }
4936
4937 if (decoder_count < numDecoders) return GenericError;
4938
4939 return Ok;
4940 }
4941
4942 /*****************************************************************************
4943 * GdipGetImageEncodersSize [GDIPLUS.@]
4944 */
4945 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
4946 {
4947 int encoder_count=0;
4948 int i;
4949 TRACE("%p %p\n", numEncoders, size);
4950
4951 if (!numEncoders || !size)
4952 return InvalidParameter;
4953
4954 for (i=0; i<NUM_CODECS; i++)
4955 {
4956 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4957 encoder_count++;
4958 }
4959
4960 *numEncoders = encoder_count;
4961 *size = encoder_count * sizeof(ImageCodecInfo);
4962
4963 return Ok;
4964 }
4965
4966 /*****************************************************************************
4967 * GdipGetImageEncoders [GDIPLUS.@]
4968 */
4969 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
4970 {
4971 int i, encoder_count=0;
4972 TRACE("%u %u %p\n", numEncoders, size, encoders);
4973
4974 if (!encoders ||
4975 size != numEncoders * sizeof(ImageCodecInfo))
4976 return GenericError;
4977
4978 for (i=0; i<NUM_CODECS; i++)
4979 {
4980 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4981 {
4982 if (encoder_count == numEncoders) return GenericError;
4983 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4984 encoder_count++;
4985 }
4986 }
4987
4988 if (encoder_count < numEncoders) return GenericError;
4989
4990 return Ok;
4991 }
4992
4993 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
4994 GDIPCONST CLSID* clsidEncoder, UINT *size)
4995 {
4996 static int calls;
4997
4998 TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
4999
5000 if(!(calls++))
5001 FIXME("not implemented\n");
5002
5003 *size = 0;
5004
5005 return NotImplemented;
5006 }
5007
5008 static PixelFormat get_16bpp_format(HBITMAP hbm)
5009 {
5010 BITMAPV4HEADER bmh;
5011 HDC hdc;
5012 PixelFormat result;
5013
5014 hdc = CreateCompatibleDC(NULL);
5015
5016 memset(&bmh, 0, sizeof(bmh));
5017 bmh.bV4Size = sizeof(bmh);
5018 bmh.bV4Width = 1;
5019 bmh.bV4Height = 1;
5020 bmh.bV4V4Compression = BI_BITFIELDS;
5021 bmh.bV4BitCount = 16;
5022
5023 GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
5024
5025 if (bmh.bV4RedMask == 0x7c00 &&
5026 bmh.bV4GreenMask == 0x3e0 &&
5027 bmh.bV4BlueMask == 0x1f)
5028 {
5029 result = PixelFormat16bppRGB555;
5030 }
5031 else if (bmh.bV4RedMask == 0xf800 &&
5032 bmh.bV4GreenMask == 0x7e0 &&
5033 bmh.bV4BlueMask == 0x1f)
5034 {
5035 result = PixelFormat16bppRGB565;
5036 }
5037 else
5038 {
5039 FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
5040 bmh.bV4GreenMask, bmh.bV4BlueMask);
5041 result = PixelFormatUndefined;
5042 }
5043
5044 DeleteDC(hdc);
5045
5046 return result;
5047 }
5048
5049 /*****************************************************************************
5050 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
5051 */
5052 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
5053 {
5054 BITMAP bm;
5055 GpStatus retval;
5056 PixelFormat format;
5057 BitmapData lockeddata;
5058
5059 TRACE("%p %p %p\n", hbm, hpal, bitmap);
5060
5061 if(!hbm || !bitmap)
5062 return InvalidParameter;
5063
5064 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
5065 return InvalidParameter;
5066
5067 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
5068 switch(bm.bmBitsPixel) {
5069 case 1:
5070 format = PixelFormat1bppIndexed;
5071 break;
5072 case 4:
5073 format = PixelFormat4bppIndexed;
5074 break;
5075 case 8:
5076 format = PixelFormat8bppIndexed;
5077 break;
5078 case 16:
5079 format = get_16bpp_format(hbm);
5080 if (format == PixelFormatUndefined)
5081 return InvalidParameter;
5082 break;
5083 case 24:
5084 format = PixelFormat24bppRGB;
5085 break;
5086 case 32:
5087 format = PixelFormat32bppRGB;
5088 break;
5089 case 48:
5090 format = PixelFormat48bppRGB;
5091 break;
5092 default:
5093 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
5094 return InvalidParameter;
5095 }
5096
5097 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
5098 format, NULL, bitmap);
5099
5100 if (retval == Ok)
5101 {
5102 retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
5103 format, &lockeddata);
5104 if (retval == Ok)
5105 {
5106 HDC hdc;
5107 char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
5108 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
5109 INT src_height;
5110
5111 hdc = CreateCompatibleDC(NULL);
5112
5113 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
5114 pbmi->bmiHeader.biBitCount = 0;
5115
5116 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
5117
5118 src_height = abs(pbmi->bmiHeader.biHeight);
5119 pbmi->bmiHeader.biHeight = -src_height;
5120
5121 GetDIBits(hdc, hbm, 0, src_height, lockeddata.Scan0, pbmi, DIB_RGB_COLORS);
5122
5123 DeleteDC(hdc);
5124
5125 GdipBitmapUnlockBits(*bitmap, &lockeddata);
5126 }
5127
5128 if (retval == Ok && hpal)
5129 {
5130 PALETTEENTRY entry[256];
5131 ColorPalette *palette=NULL;
5132 int i, num_palette_entries;
5133
5134 num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
5135 if (!num_palette_entries)
5136 retval = GenericError;
5137
5138 palette = heap_alloc_zero(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
5139 if (!palette)
5140 retval = OutOfMemory;
5141
5142 if (retval == Ok)
5143 {
5144 palette->Flags = 0;
5145 palette->Count = num_palette_entries;
5146
5147 for (i=0; i<num_palette_entries; i++)
5148 {
5149 palette->Entries[i] = 0xff000000 | entry[i].peRed << 16 |
5150 entry[i].peGreen << 8 | entry[i].peBlue;
5151 }
5152
5153 retval = GdipSetImagePalette(&(*bitmap)->image, palette);
5154 }
5155
5156 heap_free(palette);
5157 }
5158
5159 if (retval != Ok)
5160 {
5161 GdipDisposeImage(&(*bitmap)->image);
5162 *bitmap = NULL;
5163 }
5164 }
5165
5166 return retval;
5167 }
5168
5169 /*****************************************************************************
5170 * GdipCreateEffect [GDIPLUS.@]
5171 */
5172 GpStatus WINGDIPAPI GdipCreateEffect(const GUID guid, CGpEffect **effect)
5173 {
5174 FIXME("(%s, %p): stub\n", debugstr_guid(&guid), effect);
5175
5176 if(!effect)
5177 return InvalidParameter;
5178
5179 *effect = NULL;
5180
5181 return NotImplemented;
5182 }
5183
5184 /*****************************************************************************
5185 * GdipDeleteEffect [GDIPLUS.@]
5186 */
5187 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
5188 {
5189 FIXME("(%p): stub\n", effect);
5190 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
5191 * in Windows's gdiplus */
5192 return NotImplemented;
5193 }
5194
5195 /*****************************************************************************
5196 * GdipSetEffectParameters [GDIPLUS.@]
5197 */
5198 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
5199 const VOID *params, const UINT size)
5200 {
5201 static int calls;
5202
5203 TRACE("(%p,%p,%u)\n", effect, params, size);
5204
5205 if(!(calls++))
5206 FIXME("not implemented\n");
5207
5208 return NotImplemented;
5209 }
5210
5211 /*****************************************************************************
5212 * GdipGetImageFlags [GDIPLUS.@]
5213 */
5214 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
5215 {
5216 TRACE("%p %p\n", image, flags);
5217
5218 if(!image || !flags)
5219 return InvalidParameter;
5220
5221 *flags = image->flags;
5222
5223 return Ok;
5224 }
5225
5226 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
5227 {
5228 TRACE("(%d, %p)\n", control, param);
5229
5230 switch(control){
5231 case TestControlForceBilinear:
5232 if(param)
5233 FIXME("TestControlForceBilinear not handled\n");
5234 break;
5235 case TestControlNoICM:
5236 if(param)
5237 FIXME("TestControlNoICM not handled\n");
5238 break;
5239 case TestControlGetBuildNumber:
5240 *((DWORD*)param) = 3102;
5241 break;
5242 }
5243
5244 return Ok;
5245 }
5246
5247 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
5248 {
5249 TRACE("%p\n", image);
5250
5251 return Ok;
5252 }
5253
5254 /*****************************************************************************
5255 * GdipGetImageThumbnail [GDIPLUS.@]
5256 */
5257 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
5258 GpImage **ret_image, GetThumbnailImageAbort cb,
5259 VOID * cb_data)
5260 {
5261 GpStatus stat;
5262 GpGraphics *graphics;
5263 UINT srcwidth, srcheight;
5264
5265 TRACE("(%p %u %u %p %p %p)\n",
5266 image, width, height, ret_image, cb, cb_data);
5267
5268 if (!image || !ret_image)
5269 return InvalidParameter;
5270
5271 if (!width) width = 120;
5272 if (!height) height = 120;
5273
5274 GdipGetImageWidth(image, &srcwidth);
5275 GdipGetImageHeight(image, &srcheight);
5276
5277 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
5278 NULL, (GpBitmap**)ret_image);
5279
5280 if (stat == Ok)
5281 {
5282 stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
5283
5284 if (stat == Ok)
5285 {
5286 stat = GdipDrawImageRectRectI(graphics, image,
5287 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
5288 NULL, NULL, NULL);
5289
5290 GdipDeleteGraphics(graphics);
5291 }
5292
5293 if (stat != Ok)
5294 {
5295 GdipDisposeImage(*ret_image);
5296 *ret_image = NULL;
5297 }
5298 }
5299
5300 return stat;
5301 }
5302
5303 /*****************************************************************************
5304 * GdipImageRotateFlip [GDIPLUS.@]
5305 */
5306 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
5307 {
5308 GpBitmap *new_bitmap;
5309 GpBitmap *bitmap;
5310 int bpp, bytesperpixel;
5311 BOOL rotate_90, flip_x, flip_y;
5312 int src_x_offset, src_y_offset;
5313 LPBYTE src_origin;
5314 UINT x, y, width, height;
5315 BitmapData src_lock, dst_lock;
5316 GpStatus stat;
5317 BOOL unlock;
5318
5319 TRACE("(%p, %u)\n", image, type);
5320
5321 if (!image)
5322 return InvalidParameter;
5323 if (!image_lock(image, &unlock))
5324 return ObjectBusy;
5325
5326 rotate_90 = type&1;
5327 flip_x = (type&6) == 2 || (type&6) == 4;
5328 flip_y = (type&3) == 1 || (type&3) == 2;
5329
5330 if (image->type != ImageTypeBitmap)
5331 {
5332 FIXME("Not implemented for type %i\n", image->type);
5333 image_unlock(image, unlock);
5334 return NotImplemented;
5335 }
5336
5337 bitmap = (GpBitmap*)image;
5338 bpp = PIXELFORMATBPP(bitmap->format);
5339
5340 if (bpp < 8)
5341 {
5342 FIXME("Not implemented for %i bit images\n", bpp);
5343 image_unlock(image, unlock);
5344 return NotImplemented;
5345 }
5346
5347 if (rotate_90)
5348 {
5349 width = bitmap->height;
5350 height = bitmap->width;
5351 }
5352 else
5353 {
5354 width = bitmap->width;
5355 height = bitmap->height;
5356 }
5357
5358 bytesperpixel = bpp/8;
5359
5360 stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
5361
5362 if (stat != Ok)
5363 {
5364 image_unlock(image, unlock);
5365 return stat;
5366 }
5367
5368 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
5369
5370 if (stat == Ok)
5371 {
5372 stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
5373
5374 if (stat == Ok)
5375 {
5376 LPBYTE src_row, src_pixel;
5377 LPBYTE dst_row, dst_pixel;
5378
5379 src_origin = src_lock.Scan0;
5380 if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
5381 if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
5382
5383 if (rotate_90)
5384 {
5385 if (flip_y) src_x_offset = -src_lock.Stride;
5386 else src_x_offset = src_lock.Stride;
5387 if (flip_x) src_y_offset = -bytesperpixel;
5388 else src_y_offset = bytesperpixel;
5389 }
5390 else
5391 {
5392 if (flip_x) src_x_offset = -bytesperpixel;
5393 else src_x_offset = bytesperpixel;
5394 if (flip_y) src_y_offset = -src_lock.Stride;
5395 else src_y_offset = src_lock.Stride;
5396 }
5397
5398 src_row = src_origin;
5399 dst_row = dst_lock.Scan0;
5400 for (y=0; y<height; y++)
5401 {
5402 src_pixel = src_row;
5403 dst_pixel = dst_row;
5404 for (x=0; x<width; x++)
5405 {
5406 /* FIXME: This could probably be faster without memcpy. */
5407 memcpy(dst_pixel, src_pixel, bytesperpixel);
5408 dst_pixel += bytesperpixel;
5409 src_pixel += src_x_offset;
5410 }
5411 src_row += src_y_offset;
5412 dst_row += dst_lock.Stride;
5413 }
5414
5415 GdipBitmapUnlockBits(new_bitmap, &dst_lock);
5416 }
5417
5418 GdipBitmapUnlockBits(bitmap, &src_lock);
5419 }
5420
5421 if (stat == Ok)
5422 move_bitmap(bitmap, new_bitmap, FALSE);
5423 else
5424 GdipDisposeImage(&new_bitmap->image);
5425
5426 image_unlock(image, unlock);
5427 return stat;
5428 }
5429
5430 /*****************************************************************************
5431 * GdipImageSetAbort [GDIPLUS.@]
5432 */
5433 GpStatus WINGDIPAPI GdipImageSetAbort(GpImage *image, GdiplusAbort *pabort)
5434 {
5435 TRACE("(%p, %p)\n", image, pabort);
5436
5437 if (!image)
5438 return InvalidParameter;
5439
5440 if (pabort)
5441 FIXME("Abort callback is not supported.\n");
5442
5443 return Ok;
5444 }
5445
5446 /*****************************************************************************
5447 * GdipBitmapConvertFormat [GDIPLUS.@]
5448 */
5449 GpStatus WINGDIPAPI GdipBitmapConvertFormat(GpBitmap *bitmap, PixelFormat format, DitherType dithertype,
5450 PaletteType palettetype, ColorPalette *palette, REAL alphathreshold)
5451 {
5452 FIXME("(%p, 0x%08x, %d, %d, %p, %f): stub\n", bitmap, format, dithertype, palettetype, palette, alphathreshold);
5453 return NotImplemented;
5454 }
5455
5456 static void set_histogram_point_argb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5457 {
5458 ch0[ color >> 24 ]++;
5459 ch1[(color >> 16) & 0xff]++;
5460 ch2[(color >> 8) & 0xff]++;
5461 ch3[ color & 0xff]++;
5462 }
5463
5464 static void set_histogram_point_pargb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5465 {
5466 BYTE alpha = color >> 24;
5467
5468 ch0[alpha]++;
5469 ch1[(((color >> 16) & 0xff) * alpha) / 0xff]++;
5470 ch2[(((color >> 8) & 0xff) * alpha) / 0xff]++;
5471 ch3[(( color & 0xff) * alpha) / 0xff]++;
5472 }
5473
5474 static void set_histogram_point_rgb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5475 {
5476 ch0[(color >> 16) & 0xff]++;
5477 ch1[(color >> 8) & 0xff]++;
5478 ch2[ color & 0xff]++;
5479 }
5480
5481 static void set_histogram_point_gray(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5482 {
5483 ch0[(76 * ((color >> 16) & 0xff) + 150 * ((color >> 8) & 0xff) + 29 * (color & 0xff)) / 0xff]++;
5484 }
5485
5486 static void set_histogram_point_b(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5487 {
5488 ch0[color & 0xff]++;
5489 }
5490
5491 static void set_histogram_point_g(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5492 {
5493 ch0[(color >> 8) & 0xff]++;
5494 }
5495
5496 static void set_histogram_point_r(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5497 {
5498 ch0[(color >> 16) & 0xff]++;
5499 }
5500
5501 static void set_histogram_point_a(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5502 {
5503 ch0[(color >> 24) & 0xff]++;
5504 }
5505
5506 /*****************************************************************************
5507 * GdipBitmapGetHistogram [GDIPLUS.@]
5508 */
5509 GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap *bitmap, HistogramFormat format, UINT num_of_entries,
5510 UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5511 {
5512 static void (* const set_histogram_point[])(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3) =
5513 {
5514 set_histogram_point_argb,
5515 set_histogram_point_pargb,
5516 set_histogram_point_rgb,
5517 set_histogram_point_gray,
5518 set_histogram_point_b,
5519 set_histogram_point_g,
5520 set_histogram_point_r,
5521 set_histogram_point_a,
5522 };
5523 UINT width, height, x, y;
5524
5525 TRACE("(%p, %d, %u, %p, %p, %p, %p)\n", bitmap, format, num_of_entries,
5526 ch0, ch1, ch2, ch3);
5527
5528 if (!bitmap || num_of_entries != 256)
5529 return InvalidParameter;
5530
5531 /* Make sure passed channel pointers match requested format */
5532 switch (format)
5533 {
5534 case HistogramFormatARGB:
5535 case HistogramFormatPARGB:
5536 if (!ch0 || !ch1 || !ch2 || !ch3)
5537 return InvalidParameter;
5538 memset(ch0, 0, num_of_entries * sizeof(UINT));
5539 memset(ch1, 0, num_of_entries * sizeof(UINT));
5540 memset(ch2, 0, num_of_entries * sizeof(UINT));
5541 memset(ch3, 0, num_of_entries * sizeof(UINT));
5542 break;
5543 case HistogramFormatRGB:
5544 if (!ch0 || !ch1 || !ch2 || ch3)
5545 return InvalidParameter;
5546 memset(ch0, 0, num_of_entries * sizeof(UINT));
5547 memset(ch1, 0, num_of_entries * sizeof(UINT));
5548 memset(ch2, 0, num_of_entries * sizeof(UINT));
5549 break;
5550 case HistogramFormatGray:
5551 case HistogramFormatB:
5552 case HistogramFormatG:
5553 case HistogramFormatR:
5554 case HistogramFormatA:
5555 if (!ch0 || ch1 || ch2 || ch3)
5556 return InvalidParameter;
5557 memset(ch0, 0, num_of_entries * sizeof(UINT));
5558 break;
5559 default:
5560 WARN("Invalid histogram format requested, %d\n", format);
5561 return InvalidParameter;
5562 }
5563
5564 GdipGetImageWidth(&bitmap->image, &width);
5565 GdipGetImageHeight(&bitmap->image, &height);
5566
5567 for (y = 0; y < height; y++)
5568 for (x = 0; x < width; x++)
5569 {
5570 ARGB color;
5571
5572 GdipBitmapGetPixel(bitmap, x, y, &color);
5573 set_histogram_point[format](color, ch0, ch1, ch2, ch3);
5574 }
5575
5576 return Ok;
5577 }
5578
5579 /*****************************************************************************
5580 * GdipBitmapGetHistogramSize [GDIPLUS.@]
5581 */
5582 GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(HistogramFormat format, UINT *num_of_entries)
5583 {
5584 TRACE("(%d, %p)\n", format, num_of_entries);
5585
5586 if (!num_of_entries)
5587 return InvalidParameter;
5588
5589 *num_of_entries = 256;
5590 return Ok;
5591 }
Windows API implementation