[GDIPLUS] Sync with Wine Staging 4.0. CORE-15682
[reactos.git] / dll / win32 / gdiplus / image.c
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_WICPixelFormat4bppIndexed, PixelFormat4bppIndexed, WICBitmapPaletteTypeFixedHalftone8 },
59 { &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
60 { &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
61 { &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, WICBitmapPaletteTypeFixedHalftone256 },
62 { &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
63 { &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
64 { &GUID_WICPixelFormat48bppRGB, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
65 { &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedHalftone256 },
66 { &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, WICBitmapPaletteTypeFixedHalftone256 },
67 { &GUID_WICPixelFormat32bppCMYK, PixelFormat32bppCMYK, WICBitmapPaletteTypeFixedHalftone256 },
68 { &GUID_WICPixelFormat32bppGrayFloat, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedGray256 },
69 { &GUID_WICPixelFormat64bppCMYK, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
70 { &GUID_WICPixelFormat64bppRGBA, PixelFormat48bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
71 { NULL }
72 };
73
74 static ColorPalette *get_palette(IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)
75 {
76 HRESULT hr;
77 IWICImagingFactory *factory;
78 IWICPalette *wic_palette;
79 ColorPalette *palette = NULL;
80
81 hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
82 if (hr != S_OK) return NULL;
83
84 hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
85 if (hr == S_OK)
86 {
87 hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
88 if (frame)
89 hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
90 if (hr != S_OK)
91 {
92 TRACE("using predefined palette %#x\n", palette_type);
93 hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
94 }
95 if (hr == S_OK)
96 {
97 WICBitmapPaletteType type;
98 BOOL alpha;
99 UINT count;
100
101 IWICPalette_GetColorCount(wic_palette, &count);
102 palette = heap_alloc(2 * sizeof(UINT) + count * sizeof(ARGB));
103 IWICPalette_GetColors(wic_palette, count, palette->Entries, &palette->Count);
104
105 IWICPalette_GetType(wic_palette, &type);
106 switch(type) {
107 case WICBitmapPaletteTypeFixedGray4:
108 case WICBitmapPaletteTypeFixedGray16:
109 case WICBitmapPaletteTypeFixedGray256:
110 palette->Flags = PaletteFlagsGrayScale;
111 break;
112 case WICBitmapPaletteTypeFixedHalftone8:
113 case WICBitmapPaletteTypeFixedHalftone27:
114 case WICBitmapPaletteTypeFixedHalftone64:
115 case WICBitmapPaletteTypeFixedHalftone125:
116 case WICBitmapPaletteTypeFixedHalftone216:
117 case WICBitmapPaletteTypeFixedHalftone252:
118 case WICBitmapPaletteTypeFixedHalftone256:
119 palette->Flags = PaletteFlagsHalftone;
120 break;
121 default:
122 palette->Flags = 0;
123 }
124 IWICPalette_HasAlpha(wic_palette, &alpha);
125 if(alpha)
126 palette->Flags |= PaletteFlagsHasAlpha;
127 }
128 IWICPalette_Release(wic_palette);
129 }
130 IWICImagingFactory_Release(factory);
131 return palette;
132 }
133
134 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
135 RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
136 {
137 FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
138 /*
139 * Note: According to Jose Roca's GDI+ docs, this function is not
140 * implemented in Windows's GDI+.
141 */
142 return NotImplemented;
143 }
144
145 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
146 INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
147 GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
148 {
149 FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
150 /*
151 * Note: According to Jose Roca's GDI+ docs, this function is not
152 * implemented in Windows's GDI+.
153 */
154 return NotImplemented;
155 }
156
157 static inline void getpixel_1bppIndexed(BYTE *index, const BYTE *row, UINT x)
158 {
159 *index = (row[x/8]>>(7-x%8)) & 1;
160 }
161
162 static inline void getpixel_4bppIndexed(BYTE *index, const BYTE *row, UINT x)
163 {
164 if (x & 1)
165 *index = row[x/2]&0xf;
166 else
167 *index = row[x/2]>>4;
168 }
169
170 static inline void getpixel_8bppIndexed(BYTE *index, const BYTE *row, UINT x)
171 {
172 *index = row[x];
173 }
174
175 static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
176 const BYTE *row, UINT x)
177 {
178 *r = *g = *b = row[x*2+1];
179 *a = 255;
180 }
181
182 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
183 const BYTE *row, UINT x)
184 {
185 WORD pixel = *((const WORD*)(row)+x);
186 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
187 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
188 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
189 *a = 255;
190 }
191
192 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
193 const BYTE *row, UINT x)
194 {
195 WORD pixel = *((const WORD*)(row)+x);
196 *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
197 *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
198 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
199 *a = 255;
200 }
201
202 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
203 const BYTE *row, UINT x)
204 {
205 WORD pixel = *((const WORD*)(row)+x);
206 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
207 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
208 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
209 if ((pixel&0x8000) == 0x8000)
210 *a = 255;
211 else
212 *a = 0;
213 }
214
215 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
216 const BYTE *row, UINT x)
217 {
218 *r = row[x*3+2];
219 *g = row[x*3+1];
220 *b = row[x*3];
221 *a = 255;
222 }
223
224 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
225 const BYTE *row, UINT x)
226 {
227 *r = row[x*4+2];
228 *g = row[x*4+1];
229 *b = row[x*4];
230 *a = 255;
231 }
232
233 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
234 const BYTE *row, UINT x)
235 {
236 *r = row[x*4+2];
237 *g = row[x*4+1];
238 *b = row[x*4];
239 *a = row[x*4+3];
240 }
241
242 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
243 const BYTE *row, UINT x)
244 {
245 *a = row[x*4+3];
246 if (*a == 0)
247 *r = *g = *b = 0;
248 else
249 {
250 *r = row[x*4+2] * 255 / *a;
251 *g = row[x*4+1] * 255 / *a;
252 *b = row[x*4] * 255 / *a;
253 }
254 }
255
256 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
257 const BYTE *row, UINT x)
258 {
259 *r = row[x*6+5];
260 *g = row[x*6+3];
261 *b = row[x*6+1];
262 *a = 255;
263 }
264
265 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
266 const BYTE *row, UINT x)
267 {
268 *r = row[x*8+5];
269 *g = row[x*8+3];
270 *b = row[x*8+1];
271 *a = row[x*8+7];
272 }
273
274 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
275 const BYTE *row, UINT x)
276 {
277 *a = row[x*8+7];
278 if (*a == 0)
279 *r = *g = *b = 0;
280 else
281 {
282 *r = row[x*8+5] * 255 / *a;
283 *g = row[x*8+3] * 255 / *a;
284 *b = row[x*8+1] * 255 / *a;
285 }
286 }
287
288 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
289 ARGB *color)
290 {
291 BYTE r, g, b, a;
292 BYTE index;
293 BYTE *row;
294
295 if(!bitmap || !color ||
296 x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
297 return InvalidParameter;
298
299 row = bitmap->bits+bitmap->stride*y;
300
301 switch (bitmap->format)
302 {
303 case PixelFormat1bppIndexed:
304 getpixel_1bppIndexed(&index,row,x);
305 break;
306 case PixelFormat4bppIndexed:
307 getpixel_4bppIndexed(&index,row,x);
308 break;
309 case PixelFormat8bppIndexed:
310 getpixel_8bppIndexed(&index,row,x);
311 break;
312 case PixelFormat16bppGrayScale:
313 getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
314 break;
315 case PixelFormat16bppRGB555:
316 getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
317 break;
318 case PixelFormat16bppRGB565:
319 getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
320 break;
321 case PixelFormat16bppARGB1555:
322 getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
323 break;
324 case PixelFormat24bppRGB:
325 getpixel_24bppRGB(&r,&g,&b,&a,row,x);
326 break;
327 case PixelFormat32bppRGB:
328 getpixel_32bppRGB(&r,&g,&b,&a,row,x);
329 break;
330 case PixelFormat32bppARGB:
331 getpixel_32bppARGB(&r,&g,&b,&a,row,x);
332 break;
333 case PixelFormat32bppPARGB:
334 getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
335 break;
336 case PixelFormat48bppRGB:
337 getpixel_48bppRGB(&r,&g,&b,&a,row,x);
338 break;
339 case PixelFormat64bppARGB:
340 getpixel_64bppARGB(&r,&g,&b,&a,row,x);
341 break;
342 case PixelFormat64bppPARGB:
343 getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
344 break;
345 default:
346 FIXME("not implemented for format 0x%x\n", bitmap->format);
347 return NotImplemented;
348 }
349
350 if (bitmap->format & PixelFormatIndexed)
351 *color = bitmap->image.palette->Entries[index];
352 else
353 *color = a<<24|r<<16|g<<8|b;
354
355 return Ok;
356 }
357
358 static inline UINT get_palette_index(BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)
359 {
360 BYTE index = 0;
361 int best_distance = 0x7fff;
362 int distance;
363 UINT i;
364
365 if (!palette) return 0;
366 /* This algorithm scans entire palette,
367 computes difference from desired color (all color components have equal weight)
368 and returns the index of color with least difference.
369
370 Note: Maybe it could be replaced with a better algorithm for better image quality
371 and performance, though better algorithm would probably need some pre-built lookup
372 tables and thus may actually be slower if this method is called only few times per
373 every image.
374 */
375 for(i=0;i<palette->Count;i++) {
376 ARGB color=palette->Entries[i];
377 distance=abs(b-(color & 0xff)) + abs(g-(color>>8 & 0xff)) + abs(r-(color>>16 & 0xff)) + abs(a-(color>>24 & 0xff));
378 if (distance<best_distance) {
379 best_distance=distance;
380 index=i;
381 }
382 }
383 return index;
384 }
385
386 static inline void setpixel_8bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
387 BYTE *row, UINT x, ColorPalette *palette)
388 {
389 BYTE index = get_palette_index(r,g,b,a,palette);
390 row[x]=index;
391 }
392
393 static inline void setpixel_1bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
394 BYTE *row, UINT x, ColorPalette *palette)
395 {
396 row[x/8] = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
397 }
398
399 static inline void setpixel_4bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
400 BYTE *row, UINT x, ColorPalette *palette)
401 {
402 if (x & 1)
403 row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
404 else
405 row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
406 }
407
408 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
409 BYTE *row, UINT x)
410 {
411 *((WORD*)(row)+x) = (r+g+b)*85;
412 }
413
414 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
415 BYTE *row, UINT x)
416 {
417 *((WORD*)(row)+x) = (r<<7&0x7c00)|
418 (g<<2&0x03e0)|
419 (b>>3&0x001f);
420 }
421
422 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
423 BYTE *row, UINT x)
424 {
425 *((WORD*)(row)+x) = (r<<8&0xf800)|
426 (g<<3&0x07e0)|
427 (b>>3&0x001f);
428 }
429
430 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
431 BYTE *row, UINT x)
432 {
433 *((WORD*)(row)+x) = (a<<8&0x8000)|
434 (r<<7&0x7c00)|
435 (g<<2&0x03e0)|
436 (b>>3&0x001f);
437 }
438
439 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
440 BYTE *row, UINT x)
441 {
442 row[x*3+2] = r;
443 row[x*3+1] = g;
444 row[x*3] = b;
445 }
446
447 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
448 BYTE *row, UINT x)
449 {
450 *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
451 }
452
453 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
454 BYTE *row, UINT x)
455 {
456 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
457 }
458
459 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
460 BYTE *row, UINT x)
461 {
462 r = r * a / 255;
463 g = g * a / 255;
464 b = b * a / 255;
465 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
466 }
467
468 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
469 BYTE *row, UINT x)
470 {
471 row[x*6+5] = row[x*6+4] = r;
472 row[x*6+3] = row[x*6+2] = g;
473 row[x*6+1] = row[x*6] = b;
474 }
475
476 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
477 BYTE *row, UINT x)
478 {
479 UINT64 a64=a, r64=r, g64=g, b64=b;
480 *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
481 }
482
483 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
484 BYTE *row, UINT x)
485 {
486 UINT64 a64, r64, g64, b64;
487 a64 = a * 257;
488 r64 = r * a / 255;
489 g64 = g * a / 255;
490 b64 = b * a / 255;
491 *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
492 }
493
494 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
495 ARGB color)
496 {
497 BYTE a, r, g, b;
498 BYTE *row;
499
500 if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
501 return InvalidParameter;
502
503 a = color>>24;
504 r = color>>16;
505 g = color>>8;
506 b = color;
507
508 row = bitmap->bits + bitmap->stride * y;
509
510 switch (bitmap->format)
511 {
512 case PixelFormat16bppGrayScale:
513 setpixel_16bppGrayScale(r,g,b,a,row,x);
514 break;
515 case PixelFormat16bppRGB555:
516 setpixel_16bppRGB555(r,g,b,a,row,x);
517 break;
518 case PixelFormat16bppRGB565:
519 setpixel_16bppRGB565(r,g,b,a,row,x);
520 break;
521 case PixelFormat16bppARGB1555:
522 setpixel_16bppARGB1555(r,g,b,a,row,x);
523 break;
524 case PixelFormat24bppRGB:
525 setpixel_24bppRGB(r,g,b,a,row,x);
526 break;
527 case PixelFormat32bppRGB:
528 setpixel_32bppRGB(r,g,b,a,row,x);
529 break;
530 case PixelFormat32bppARGB:
531 setpixel_32bppARGB(r,g,b,a,row,x);
532 break;
533 case PixelFormat32bppPARGB:
534 setpixel_32bppPARGB(r,g,b,a,row,x);
535 break;
536 case PixelFormat48bppRGB:
537 setpixel_48bppRGB(r,g,b,a,row,x);
538 break;
539 case PixelFormat64bppARGB:
540 setpixel_64bppARGB(r,g,b,a,row,x);
541 break;
542 case PixelFormat64bppPARGB:
543 setpixel_64bppPARGB(r,g,b,a,row,x);
544 break;
545 case PixelFormat8bppIndexed:
546 setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
547 break;
548 case PixelFormat4bppIndexed:
549 setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
550 break;
551 case PixelFormat1bppIndexed:
552 setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
553 break;
554 default:
555 FIXME("not implemented for format 0x%x\n", bitmap->format);
556 return NotImplemented;
557 }
558
559 return Ok;
560 }
561
562 GpStatus convert_pixels(INT width, INT height,
563 INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
564 INT src_stride, const BYTE *src_bits, PixelFormat src_format,
565 ColorPalette *palette)
566 {
567 INT x, y;
568
569 if (src_format == dst_format ||
570 (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
571 {
572 UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
573 for (y=0; y<height; y++)
574 memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
575 return Ok;
576 }
577
578 #define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
579 for (y=0; y<height; y++) \
580 for (x=0; x<width; x++) { \
581 BYTE index; \
582 ARGB argb; \
583 BYTE *color = (BYTE *)&argb; \
584 getpixel_function(&index, src_bits+src_stride*y, x); \
585 argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
586 setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
587 } \
588 return Ok; \
589 } while (0);
590
591 #define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
592 for (y=0; y<height; y++) \
593 for (x=0; x<width; x++) { \
594 BYTE r, g, b, a; \
595 getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
596 setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
597 } \
598 return Ok; \
599 } while (0);
600
601 #define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
602 for (y=0; y<height; y++) \
603 for (x=0; x<width; x++) { \
604 BYTE r, g, b, a; \
605 getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
606 setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
607 } \
608 return Ok; \
609 } while (0);
610
611 switch (src_format)
612 {
613 case PixelFormat1bppIndexed:
614 switch (dst_format)
615 {
616 case PixelFormat16bppGrayScale:
617 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
618 case PixelFormat16bppRGB555:
619 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
620 case PixelFormat16bppRGB565:
621 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
622 case PixelFormat16bppARGB1555:
623 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
624 case PixelFormat24bppRGB:
625 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
626 case PixelFormat32bppRGB:
627 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
628 case PixelFormat32bppARGB:
629 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
630 case PixelFormat32bppPARGB:
631 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
632 case PixelFormat48bppRGB:
633 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
634 case PixelFormat64bppARGB:
635 convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
636 default:
637 break;
638 }
639 break;
640 case PixelFormat4bppIndexed:
641 switch (dst_format)
642 {
643 case PixelFormat16bppGrayScale:
644 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
645 case PixelFormat16bppRGB555:
646 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
647 case PixelFormat16bppRGB565:
648 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
649 case PixelFormat16bppARGB1555:
650 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
651 case PixelFormat24bppRGB:
652 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
653 case PixelFormat32bppRGB:
654 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
655 case PixelFormat32bppARGB:
656 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
657 case PixelFormat32bppPARGB:
658 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
659 case PixelFormat48bppRGB:
660 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
661 case PixelFormat64bppARGB:
662 convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
663 default:
664 break;
665 }
666 break;
667 case PixelFormat8bppIndexed:
668 switch (dst_format)
669 {
670 case PixelFormat16bppGrayScale:
671 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
672 case PixelFormat16bppRGB555:
673 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
674 case PixelFormat16bppRGB565:
675 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
676 case PixelFormat16bppARGB1555:
677 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
678 case PixelFormat24bppRGB:
679 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
680 case PixelFormat32bppRGB:
681 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
682 case PixelFormat32bppARGB:
683 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
684 case PixelFormat32bppPARGB:
685 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
686 case PixelFormat48bppRGB:
687 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
688 case PixelFormat64bppARGB:
689 convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
690 default:
691 break;
692 }
693 break;
694 case PixelFormat16bppGrayScale:
695 switch (dst_format)
696 {
697 case PixelFormat1bppIndexed:
698 convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
699 case PixelFormat8bppIndexed:
700 convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
701 case PixelFormat16bppRGB555:
702 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
703 case PixelFormat16bppRGB565:
704 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
705 case PixelFormat16bppARGB1555:
706 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
707 case PixelFormat24bppRGB:
708 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
709 case PixelFormat32bppRGB:
710 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
711 case PixelFormat32bppARGB:
712 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
713 case PixelFormat32bppPARGB:
714 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
715 case PixelFormat48bppRGB:
716 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
717 case PixelFormat64bppARGB:
718 convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
719 default:
720 break;
721 }
722 break;
723 case PixelFormat16bppRGB555:
724 switch (dst_format)
725 {
726 case PixelFormat1bppIndexed:
727 convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
728 case PixelFormat8bppIndexed:
729 convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
730 case PixelFormat16bppGrayScale:
731 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
732 case PixelFormat16bppRGB565:
733 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
734 case PixelFormat16bppARGB1555:
735 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
736 case PixelFormat24bppRGB:
737 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
738 case PixelFormat32bppRGB:
739 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
740 case PixelFormat32bppARGB:
741 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
742 case PixelFormat32bppPARGB:
743 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
744 case PixelFormat48bppRGB:
745 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
746 case PixelFormat64bppARGB:
747 convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
748 default:
749 break;
750 }
751 break;
752 case PixelFormat16bppRGB565:
753 switch (dst_format)
754 {
755 case PixelFormat1bppIndexed:
756 convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
757 case PixelFormat8bppIndexed:
758 convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
759 case PixelFormat16bppGrayScale:
760 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
761 case PixelFormat16bppRGB555:
762 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
763 case PixelFormat16bppARGB1555:
764 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
765 case PixelFormat24bppRGB:
766 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
767 case PixelFormat32bppRGB:
768 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
769 case PixelFormat32bppARGB:
770 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
771 case PixelFormat32bppPARGB:
772 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
773 case PixelFormat48bppRGB:
774 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
775 case PixelFormat64bppARGB:
776 convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
777 default:
778 break;
779 }
780 break;
781 case PixelFormat16bppARGB1555:
782 switch (dst_format)
783 {
784 case PixelFormat1bppIndexed:
785 convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
786 case PixelFormat8bppIndexed:
787 convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
788 case PixelFormat16bppGrayScale:
789 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
790 case PixelFormat16bppRGB555:
791 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
792 case PixelFormat16bppRGB565:
793 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
794 case PixelFormat24bppRGB:
795 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
796 case PixelFormat32bppRGB:
797 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
798 case PixelFormat32bppARGB:
799 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
800 case PixelFormat32bppPARGB:
801 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
802 case PixelFormat48bppRGB:
803 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
804 case PixelFormat64bppARGB:
805 convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
806 default:
807 break;
808 }
809 break;
810 case PixelFormat24bppRGB:
811 switch (dst_format)
812 {
813 case PixelFormat1bppIndexed:
814 convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
815 case PixelFormat8bppIndexed:
816 convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
817 case PixelFormat16bppGrayScale:
818 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
819 case PixelFormat16bppRGB555:
820 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
821 case PixelFormat16bppRGB565:
822 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
823 case PixelFormat16bppARGB1555:
824 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
825 case PixelFormat32bppRGB:
826 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
827 case PixelFormat32bppARGB:
828 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
829 case PixelFormat32bppPARGB:
830 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
831 case PixelFormat48bppRGB:
832 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
833 case PixelFormat64bppARGB:
834 convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
835 default:
836 break;
837 }
838 break;
839 case PixelFormat32bppRGB:
840 switch (dst_format)
841 {
842 case PixelFormat1bppIndexed:
843 convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
844 case PixelFormat8bppIndexed:
845 convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
846 case PixelFormat16bppGrayScale:
847 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
848 case PixelFormat16bppRGB555:
849 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
850 case PixelFormat16bppRGB565:
851 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
852 case PixelFormat16bppARGB1555:
853 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
854 case PixelFormat24bppRGB:
855 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
856 case PixelFormat32bppARGB:
857 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
858 case PixelFormat32bppPARGB:
859 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
860 case PixelFormat48bppRGB:
861 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
862 case PixelFormat64bppARGB:
863 convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
864 default:
865 break;
866 }
867 break;
868 case PixelFormat32bppARGB:
869 switch (dst_format)
870 {
871 case PixelFormat1bppIndexed:
872 convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
873 case PixelFormat8bppIndexed:
874 convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
875 case PixelFormat16bppGrayScale:
876 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
877 case PixelFormat16bppRGB555:
878 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
879 case PixelFormat16bppRGB565:
880 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
881 case PixelFormat16bppARGB1555:
882 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
883 case PixelFormat24bppRGB:
884 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
885 case PixelFormat32bppPARGB:
886 convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
887 return Ok;
888 case PixelFormat48bppRGB:
889 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
890 case PixelFormat64bppARGB:
891 convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
892 default:
893 break;
894 }
895 break;
896 case PixelFormat32bppPARGB:
897 switch (dst_format)
898 {
899 case PixelFormat1bppIndexed:
900 convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
901 case PixelFormat8bppIndexed:
902 convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
903 case PixelFormat16bppGrayScale:
904 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
905 case PixelFormat16bppRGB555:
906 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
907 case PixelFormat16bppRGB565:
908 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
909 case PixelFormat16bppARGB1555:
910 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
911 case PixelFormat24bppRGB:
912 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
913 case PixelFormat32bppRGB:
914 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
915 case PixelFormat32bppARGB:
916 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
917 case PixelFormat48bppRGB:
918 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
919 case PixelFormat64bppARGB:
920 convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
921 default:
922 break;
923 }
924 break;
925 case PixelFormat48bppRGB:
926 switch (dst_format)
927 {
928 case PixelFormat1bppIndexed:
929 convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
930 case PixelFormat8bppIndexed:
931 convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
932 case PixelFormat16bppGrayScale:
933 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
934 case PixelFormat16bppRGB555:
935 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
936 case PixelFormat16bppRGB565:
937 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
938 case PixelFormat16bppARGB1555:
939 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
940 case PixelFormat24bppRGB:
941 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
942 case PixelFormat32bppRGB:
943 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
944 case PixelFormat32bppARGB:
945 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
946 case PixelFormat32bppPARGB:
947 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
948 case PixelFormat64bppARGB:
949 convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
950 default:
951 break;
952 }
953 break;
954 case PixelFormat64bppARGB:
955 switch (dst_format)
956 {
957 case PixelFormat1bppIndexed:
958 convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
959 case PixelFormat8bppIndexed:
960 convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
961 case PixelFormat16bppGrayScale:
962 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
963 case PixelFormat16bppRGB555:
964 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
965 case PixelFormat16bppRGB565:
966 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
967 case PixelFormat16bppARGB1555:
968 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
969 case PixelFormat24bppRGB:
970 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
971 case PixelFormat32bppRGB:
972 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
973 case PixelFormat32bppARGB:
974 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
975 case PixelFormat32bppPARGB:
976 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
977 case PixelFormat48bppRGB:
978 convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
979 default:
980 break;
981 }
982 break;
983 case PixelFormat64bppPARGB:
984 switch (dst_format)
985 {
986 case PixelFormat1bppIndexed:
987 convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
988 case PixelFormat8bppIndexed:
989 convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
990 case PixelFormat16bppGrayScale:
991 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
992 case PixelFormat16bppRGB555:
993 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
994 case PixelFormat16bppRGB565:
995 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
996 case PixelFormat16bppARGB1555:
997 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
998 case PixelFormat24bppRGB:
999 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
1000 case PixelFormat32bppRGB:
1001 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
1002 case PixelFormat32bppARGB:
1003 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
1004 case PixelFormat32bppPARGB:
1005 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
1006 case PixelFormat48bppRGB:
1007 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
1008 case PixelFormat64bppARGB:
1009 convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
1010 default:
1011 break;
1012 }
1013 break;
1014 default:
1015 break;
1016 }
1017
1018 #undef convert_indexed_to_rgb
1019 #undef convert_rgb_to_rgb
1020
1021 return NotImplemented;
1022 }
1023
1024 /* This function returns a pointer to an array of pixels that represents the
1025 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
1026 * flags. It is correct behavior that a user who calls this function with write
1027 * privileges can write to the whole bitmap (not just the area in rect).
1028 *
1029 * FIXME: only used portion of format is bits per pixel. */
1030 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
1031 UINT flags, PixelFormat format, BitmapData* lockeddata)
1032 {
1033 INT bitspp = PIXELFORMATBPP(format);
1034 GpRect act_rect; /* actual rect to be used */
1035 GpStatus stat;
1036 BOOL unlock;
1037
1038 TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
1039
1040 if(!lockeddata || !bitmap)
1041 return InvalidParameter;
1042 if(!image_lock(&bitmap->image, &unlock))
1043 return ObjectBusy;
1044
1045 if(rect){
1046 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
1047 (rect->Y + rect->Height > bitmap->height) || !flags)
1048 {
1049 image_unlock(&bitmap->image, unlock);
1050 return InvalidParameter;
1051 }
1052
1053 act_rect = *rect;
1054 }
1055 else{
1056 act_rect.X = act_rect.Y = 0;
1057 act_rect.Width = bitmap->width;
1058 act_rect.Height = bitmap->height;
1059 }
1060
1061 if(bitmap->lockmode)
1062 {
1063 WARN("bitmap is already locked and cannot be locked again\n");
1064 image_unlock(&bitmap->image, unlock);
1065 return WrongState;
1066 }
1067
1068 if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
1069 {
1070 /* no conversion is necessary; just use the bits directly */
1071 lockeddata->Width = act_rect.Width;
1072 lockeddata->Height = act_rect.Height;
1073 lockeddata->PixelFormat = format;
1074 lockeddata->Reserved = flags;
1075 lockeddata->Stride = bitmap->stride;
1076 lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
1077 bitmap->stride * act_rect.Y;
1078
1079 bitmap->lockmode = flags | ImageLockModeRead;
1080
1081 image_unlock(&bitmap->image, unlock);
1082 return Ok;
1083 }
1084
1085 /* Make sure we can convert to the requested format. */
1086 if (flags & ImageLockModeRead)
1087 {
1088 stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
1089 if (stat == NotImplemented)
1090 {
1091 FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
1092 image_unlock(&bitmap->image, unlock);
1093 return NotImplemented;
1094 }
1095 }
1096
1097 /* If we're opening for writing, make sure we'll be able to write back in
1098 * the original format. */
1099 if (flags & ImageLockModeWrite)
1100 {
1101 stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
1102 if (stat == NotImplemented)
1103 {
1104 FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
1105 image_unlock(&bitmap->image, unlock);
1106 return NotImplemented;
1107 }
1108 }
1109
1110 lockeddata->Width = act_rect.Width;
1111 lockeddata->Height = act_rect.Height;
1112 lockeddata->PixelFormat = format;
1113 lockeddata->Reserved = flags;
1114
1115 if(!(flags & ImageLockModeUserInputBuf))
1116 {
1117 lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
1118
1119 bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
1120
1121 if (!bitmap->bitmapbits)
1122 {
1123 image_unlock(&bitmap->image, unlock);
1124 return OutOfMemory;
1125 }
1126
1127 lockeddata->Scan0 = bitmap->bitmapbits;
1128 }
1129
1130 if (flags & ImageLockModeRead)
1131 {
1132 static BOOL fixme = FALSE;
1133
1134 if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
1135 {
1136 FIXME("Cannot copy rows that don't start at a whole byte.\n");
1137 fixme = TRUE;
1138 }
1139
1140 stat = convert_pixels(act_rect.Width, act_rect.Height,
1141 lockeddata->Stride, lockeddata->Scan0, format,
1142 bitmap->stride,
1143 bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
1144 bitmap->format, bitmap->image.palette);
1145
1146 if (stat != Ok)
1147 {
1148 heap_free(bitmap->bitmapbits);
1149 bitmap->bitmapbits = NULL;
1150 image_unlock(&bitmap->image, unlock);
1151 return stat;
1152 }
1153 }
1154
1155 bitmap->lockmode = flags | ImageLockModeRead;
1156 bitmap->lockx = act_rect.X;
1157 bitmap->locky = act_rect.Y;
1158
1159 image_unlock(&bitmap->image, unlock);
1160 return Ok;
1161 }
1162
1163 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
1164 {
1165 TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
1166
1167 if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
1168 return InvalidParameter;
1169
1170 bitmap->image.xres = xdpi;
1171 bitmap->image.yres = ydpi;
1172
1173 return Ok;
1174 }
1175
1176 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
1177 BitmapData* lockeddata)
1178 {
1179 GpStatus stat;
1180 static BOOL fixme = FALSE;
1181 BOOL unlock;
1182
1183 TRACE("(%p,%p)\n", bitmap, lockeddata);
1184
1185 if(!bitmap || !lockeddata)
1186 return InvalidParameter;
1187 if(!image_lock(&bitmap->image, &unlock))
1188 return ObjectBusy;
1189
1190 if(!bitmap->lockmode)
1191 {
1192 image_unlock(&bitmap->image, unlock);
1193 return WrongState;
1194 }
1195
1196 if(!(lockeddata->Reserved & ImageLockModeWrite)){
1197 bitmap->lockmode = 0;
1198 heap_free(bitmap->bitmapbits);
1199 bitmap->bitmapbits = NULL;
1200 image_unlock(&bitmap->image, unlock);
1201 return Ok;
1202 }
1203
1204 if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
1205 {
1206 /* we passed a direct reference; no need to do anything */
1207 bitmap->lockmode = 0;
1208 image_unlock(&bitmap->image, unlock);
1209 return Ok;
1210 }
1211
1212 if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
1213 {
1214 FIXME("Cannot copy rows that don't start at a whole byte.\n");
1215 fixme = TRUE;
1216 }
1217
1218 stat = convert_pixels(lockeddata->Width, lockeddata->Height,
1219 bitmap->stride,
1220 bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
1221 bitmap->format,
1222 lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
1223
1224 if (stat != Ok)
1225 {
1226 ERR("failed to convert pixels; this should never happen\n");
1227 }
1228
1229 heap_free(bitmap->bitmapbits);
1230 bitmap->bitmapbits = NULL;
1231 bitmap->lockmode = 0;
1232
1233 image_unlock(&bitmap->image, unlock);
1234 return stat;
1235 }
1236
1237 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
1238 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1239 {
1240 Rect area;
1241 GpStatus stat;
1242
1243 TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1244
1245 if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
1246 x < 0 || y < 0 ||
1247 x + width > srcBitmap->width || y + height > srcBitmap->height)
1248 {
1249 TRACE("<-- InvalidParameter\n");
1250 return InvalidParameter;
1251 }
1252
1253 if (format == PixelFormatDontCare)
1254 format = srcBitmap->format;
1255
1256 area.X = gdip_round(x);
1257 area.Y = gdip_round(y);
1258 area.Width = gdip_round(width);
1259 area.Height = gdip_round(height);
1260
1261 stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
1262 if (stat == Ok)
1263 {
1264 stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
1265 srcBitmap->stride,
1266 srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
1267 srcBitmap->format, srcBitmap->image.palette);
1268
1269 if (stat == Ok && srcBitmap->image.palette)
1270 {
1271 ColorPalette *src_palette, *dst_palette;
1272
1273 src_palette = srcBitmap->image.palette;
1274
1275 dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
1276
1277 if (dst_palette)
1278 {
1279 dst_palette->Flags = src_palette->Flags;
1280 dst_palette->Count = src_palette->Count;
1281 memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
1282
1283 heap_free((*dstBitmap)->image.palette);
1284 (*dstBitmap)->image.palette = dst_palette;
1285 }
1286 else
1287 stat = OutOfMemory;
1288 }
1289
1290 if (stat != Ok)
1291 GdipDisposeImage(&(*dstBitmap)->image);
1292 }
1293
1294 if (stat != Ok)
1295 *dstBitmap = NULL;
1296
1297 return stat;
1298 }
1299
1300 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
1301 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1302 {
1303 TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1304
1305 return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
1306 }
1307
1308 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
1309 {
1310 TRACE("%p, %p\n", image, cloneImage);
1311
1312 if (!image || !cloneImage)
1313 return InvalidParameter;
1314
1315 if (image->type == ImageTypeBitmap)
1316 {
1317 GpBitmap *bitmap = (GpBitmap *)image;
1318
1319 return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
1320 bitmap->format, bitmap, (GpBitmap **)cloneImage);
1321 }
1322 else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
1323 {
1324 GpMetafile *result, *metafile;
1325
1326 metafile = (GpMetafile*)image;
1327
1328 result = heap_alloc_zero(sizeof(*result));
1329 if (!result)
1330 return OutOfMemory;
1331
1332 result->image.type = ImageTypeMetafile;
1333 result->image.format = image->format;
1334 result->image.flags = image->flags;
1335 result->image.frame_count = 1;
1336 result->image.xres = image->xres;
1337 result->image.yres = image->yres;
1338 result->bounds = metafile->bounds;
1339 result->unit = metafile->unit;
1340 result->metafile_type = metafile->metafile_type;
1341 result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
1342 list_init(&result->containers);
1343
1344 if (!result->hemf)
1345 {
1346 heap_free(result);
1347 return OutOfMemory;
1348 }
1349
1350 *cloneImage = &result->image;
1351 return Ok;
1352 }
1353 else
1354 {
1355 WARN("GpImage with no image data (metafile in wrong state?)\n");
1356 return InvalidParameter;
1357 }
1358 }
1359
1360 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
1361 GpBitmap **bitmap)
1362 {
1363 GpStatus stat;
1364 IStream *stream;
1365
1366 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1367
1368 if(!filename || !bitmap)
1369 return InvalidParameter;
1370
1371 *bitmap = NULL;
1372
1373 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1374
1375 if(stat != Ok)
1376 return stat;
1377
1378 stat = GdipCreateBitmapFromStream(stream, bitmap);
1379
1380 IStream_Release(stream);
1381
1382 return stat;
1383 }
1384
1385 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
1386 VOID *bits, GpBitmap **bitmap)
1387 {
1388 DWORD height, stride;
1389 PixelFormat format;
1390
1391 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
1392
1393 if (!info || !bits || !bitmap)
1394 return InvalidParameter;
1395
1396 height = abs(info->bmiHeader.biHeight);
1397 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
1398
1399 if(info->bmiHeader.biHeight > 0) /* bottom-up */
1400 {
1401 bits = (BYTE*)bits + (height - 1) * stride;
1402 stride = -stride;
1403 }
1404
1405 switch(info->bmiHeader.biBitCount) {
1406 case 1:
1407 format = PixelFormat1bppIndexed;
1408 break;
1409 case 4:
1410 format = PixelFormat4bppIndexed;
1411 break;
1412 case 8:
1413 format = PixelFormat8bppIndexed;
1414 break;
1415 case 16:
1416 format = PixelFormat16bppRGB555;
1417 break;
1418 case 24:
1419 format = PixelFormat24bppRGB;
1420 break;
1421 case 32:
1422 format = PixelFormat32bppRGB;
1423 break;
1424 default:
1425 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
1426 *bitmap = NULL;
1427 return InvalidParameter;
1428 }
1429
1430 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
1431 bits, bitmap);
1432
1433 }
1434
1435 /* FIXME: no icm */
1436 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
1437 GpBitmap **bitmap)
1438 {
1439 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1440
1441 return GdipCreateBitmapFromFile(filename, bitmap);
1442 }
1443
1444 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
1445 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
1446 {
1447 HBITMAP hbm;
1448 GpStatus stat = InvalidParameter;
1449
1450 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
1451
1452 if(!lpBitmapName || !bitmap)
1453 return InvalidParameter;
1454
1455 /* load DIB */
1456 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
1457 LR_CREATEDIBSECTION);
1458
1459 if(hbm){
1460 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
1461 DeleteObject(hbm);
1462 }
1463
1464 return stat;
1465 }
1466
1467 static inline DWORD blend_argb_no_bkgnd_alpha(DWORD src, DWORD bkgnd)
1468 {
1469 BYTE b = (BYTE)src;
1470 BYTE g = (BYTE)(src >> 8);
1471 BYTE r = (BYTE)(src >> 16);
1472 DWORD alpha = (BYTE)(src >> 24);
1473 return ((b + ((BYTE)bkgnd * (255 - alpha) + 127) / 255) |
1474 (g + ((BYTE)(bkgnd >> 8) * (255 - alpha) + 127) / 255) << 8 |
1475 (r + ((BYTE)(bkgnd >> 16) * (255 - alpha) + 127) / 255) << 16 |
1476 (alpha << 24));
1477 }
1478
1479 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
1480 HBITMAP* hbmReturn, ARGB background)
1481 {
1482 GpStatus stat;
1483 HBITMAP result;
1484 UINT width, height;
1485 BITMAPINFOHEADER bih;
1486 LPBYTE bits;
1487 BOOL unlock;
1488
1489 TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
1490
1491 if (!bitmap || !hbmReturn) return InvalidParameter;
1492 if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
1493
1494 GdipGetImageWidth(&bitmap->image, &width);
1495 GdipGetImageHeight(&bitmap->image, &height);
1496
1497 bih.biSize = sizeof(bih);
1498 bih.biWidth = width;
1499 bih.biHeight = height;
1500 bih.biPlanes = 1;
1501 bih.biBitCount = 32;
1502 bih.biCompression = BI_RGB;
1503 bih.biSizeImage = 0;
1504 bih.biXPelsPerMeter = 0;
1505 bih.biYPelsPerMeter = 0;
1506 bih.biClrUsed = 0;
1507 bih.biClrImportant = 0;
1508
1509 result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1510 if (!result)
1511 {
1512 image_unlock(&bitmap->image, unlock);
1513 return GenericError;
1514 }
1515
1516 stat = convert_pixels(width, height, -width*4,
1517 bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB,
1518 bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
1519 if (stat != Ok)
1520 {
1521 DeleteObject(result);
1522 image_unlock(&bitmap->image, unlock);
1523 return stat;
1524 }
1525
1526 if (background & 0xffffff)
1527 {
1528 DWORD *ptr;
1529 UINT i;
1530 for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
1531 {
1532 if ((*ptr & 0xff000000) == 0xff000000) continue;
1533 *ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
1534 }
1535 }
1536
1537 *hbmReturn = result;
1538 image_unlock(&bitmap->image, unlock);
1539 return Ok;
1540 }
1541
1542 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
1543 GpGraphics* target, GpBitmap** bitmap)
1544 {
1545 GpStatus ret;
1546
1547 TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
1548
1549 if(!target || !bitmap)
1550 return InvalidParameter;
1551
1552 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
1553 NULL, bitmap);
1554
1555 if (ret == Ok)
1556 {
1557 GdipGetDpiX(target, &(*bitmap)->image.xres);
1558 GdipGetDpiY(target, &(*bitmap)->image.yres);
1559 }
1560
1561 return ret;
1562 }
1563
1564 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
1565 {
1566 GpStatus stat;
1567 ICONINFO iinfo;
1568 BITMAP bm;
1569 int ret;
1570 UINT width, height, stride;
1571 GpRect rect;
1572 BitmapData lockeddata;
1573 HDC screendc;
1574 BOOL has_alpha;
1575 int x, y;
1576 BITMAPINFOHEADER bih;
1577 DWORD *src;
1578 BYTE *dst_row;
1579 DWORD *dst;
1580
1581 TRACE("%p, %p\n", hicon, bitmap);
1582
1583 if(!bitmap || !GetIconInfo(hicon, &iinfo))
1584 return InvalidParameter;
1585
1586 /* get the size of the icon */
1587 ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
1588 if (ret == 0) {
1589 DeleteObject(iinfo.hbmColor);
1590 DeleteObject(iinfo.hbmMask);
1591 return GenericError;
1592 }
1593
1594 width = bm.bmWidth;
1595 height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
1596 stride = width * 4;
1597
1598 stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
1599 if (stat != Ok) {
1600 DeleteObject(iinfo.hbmColor);
1601 DeleteObject(iinfo.hbmMask);
1602 return stat;
1603 }
1604
1605 rect.X = 0;
1606 rect.Y = 0;
1607 rect.Width = width;
1608 rect.Height = height;
1609
1610 stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
1611 if (stat != Ok) {
1612 DeleteObject(iinfo.hbmColor);
1613 DeleteObject(iinfo.hbmMask);
1614 GdipDisposeImage(&(*bitmap)->image);
1615 return stat;
1616 }
1617
1618 bih.biSize = sizeof(bih);
1619 bih.biWidth = width;
1620 bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
1621 bih.biPlanes = 1;
1622 bih.biBitCount = 32;
1623 bih.biCompression = BI_RGB;
1624 bih.biSizeImage = 0;
1625 bih.biXPelsPerMeter = 0;
1626 bih.biYPelsPerMeter = 0;
1627 bih.biClrUsed = 0;
1628 bih.biClrImportant = 0;
1629
1630 screendc = CreateCompatibleDC(0);
1631 if (iinfo.hbmColor)
1632 {
1633 GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1634
1635 if (bm.bmBitsPixel == 32)
1636 {
1637 has_alpha = FALSE;
1638
1639 /* If any pixel has a non-zero alpha, ignore hbmMask */
1640 src = (DWORD*)lockeddata.Scan0;
1641 for (x=0; x<width && !has_alpha; x++)
1642 for (y=0; y<height && !has_alpha; y++)
1643 if ((*src++ & 0xff000000) != 0)
1644 has_alpha = TRUE;
1645 }
1646 else has_alpha = FALSE;
1647 }
1648 else
1649 {
1650 GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1651 has_alpha = FALSE;
1652 }
1653
1654 if (!has_alpha)
1655 {
1656 if (iinfo.hbmMask)
1657 {
1658 BYTE *bits = heap_alloc(height * stride);
1659
1660 /* read alpha data from the mask */
1661 if (iinfo.hbmColor)
1662 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1663 else
1664 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1665
1666 src = (DWORD*)bits;
1667 dst_row = lockeddata.Scan0;
1668 for (y=0; y<height; y++)
1669 {
1670 dst = (DWORD*)dst_row;
1671 for (x=0; x<height; x++)
1672 {
1673 DWORD src_value = *src++;
1674 if (src_value)
1675 *dst++ = 0;
1676 else
1677 *dst++ |= 0xff000000;
1678 }
1679 dst_row += lockeddata.Stride;
1680 }
1681
1682 heap_free(bits);
1683 }
1684 else
1685 {
1686 /* set constant alpha of 255 */
1687 dst_row = lockeddata.Scan0;
1688 for (y=0; y<height; y++)
1689 {
1690 dst = (DWORD*)dst_row;
1691 for (x=0; x<height; x++)
1692 *dst++ |= 0xff000000;
1693 dst_row += lockeddata.Stride;
1694 }
1695 }
1696 }
1697
1698 DeleteDC(screendc);
1699
1700 DeleteObject(iinfo.hbmColor);
1701 DeleteObject(iinfo.hbmMask);
1702
1703 GdipBitmapUnlockBits(*bitmap, &lockeddata);
1704
1705 return Ok;
1706 }
1707
1708 static void generate_halftone_palette(ARGB *entries, UINT count)
1709 {
1710 static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1711 UINT i;
1712
1713 for (i=0; i<8 && i<count; i++)
1714 {
1715 entries[i] = 0xff000000;
1716 if (i&1) entries[i] |= 0x800000;
1717 if (i&2) entries[i] |= 0x8000;
1718 if (i&4) entries[i] |= 0x80;
1719 }
1720
1721 if (8 < count)
1722 entries[i] = 0xffc0c0c0;
1723
1724 for (i=9; i<16 && i<count; i++)
1725 {
1726 entries[i] = 0xff000000;
1727 if (i&1) entries[i] |= 0xff0000;
1728 if (i&2) entries[i] |= 0xff00;
1729 if (i&4) entries[i] |= 0xff;
1730 }
1731
1732 for (i=16; i<40 && i<count; i++)
1733 {
1734 entries[i] = 0;
1735 }
1736
1737 for (i=40; i<256 && i<count; i++)
1738 {
1739 entries[i] = 0xff000000;
1740 entries[i] |= halftone_values[(i-40)%6];
1741 entries[i] |= halftone_values[((i-40)/6)%6] << 8;
1742 entries[i] |= halftone_values[((i-40)/36)%6] << 16;
1743 }
1744 }
1745
1746 static GpStatus get_screen_resolution(REAL *xres, REAL *yres)
1747 {
1748 HDC screendc = CreateCompatibleDC(0);
1749
1750 if (!screendc) return GenericError;
1751
1752 *xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
1753 *yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
1754
1755 DeleteDC(screendc);
1756
1757 return Ok;
1758 }
1759
1760 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1761 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1762 {
1763 HBITMAP hbitmap=NULL;
1764 INT row_size, dib_stride;
1765 BYTE *bits=NULL, *own_bits=NULL;
1766 REAL xres, yres;
1767 GpStatus stat;
1768
1769 TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
1770
1771 if (!bitmap) return InvalidParameter;
1772
1773 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1774 *bitmap = NULL;
1775 return InvalidParameter;
1776 }
1777
1778 if(scan0 && !stride)
1779 return InvalidParameter;
1780
1781 stat = get_screen_resolution(&xres, &yres);
1782 if (stat != Ok) return stat;
1783
1784 row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1785 dib_stride = (row_size + 3) & ~3;
1786
1787 if(stride == 0)
1788 stride = dib_stride;
1789
1790 if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
1791 {
1792 char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
1793 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
1794
1795 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1796 pbmi->bmiHeader.biWidth = width;
1797 pbmi->bmiHeader.biHeight = -height;
1798 pbmi->bmiHeader.biPlanes = 1;
1799 /* FIXME: use the rest of the data from format */
1800 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
1801 pbmi->bmiHeader.biCompression = BI_RGB;
1802 pbmi->bmiHeader.biSizeImage = 0;
1803 pbmi->bmiHeader.biXPelsPerMeter = 0;
1804 pbmi->bmiHeader.biYPelsPerMeter = 0;
1805 pbmi->bmiHeader.biClrUsed = 0;
1806 pbmi->bmiHeader.biClrImportant = 0;
1807
1808 hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1809
1810 if (!hbitmap) return GenericError;
1811
1812 stride = dib_stride;
1813 }
1814 else
1815 {
1816 /* Not a GDI format; don't try to make an HBITMAP. */
1817 if (scan0)
1818 bits = scan0;
1819 else
1820 {
1821 INT size = abs(stride) * height;
1822
1823 own_bits = bits = heap_alloc_zero(size);
1824 if (!own_bits) return OutOfMemory;
1825
1826 if (stride < 0)
1827 bits += stride * (1 - height);
1828 }
1829 }
1830
1831 *bitmap = heap_alloc_zero(sizeof(GpBitmap));
1832 if(!*bitmap)
1833 {
1834 DeleteObject(hbitmap);
1835 heap_free(own_bits);
1836 return OutOfMemory;
1837 }
1838
1839 (*bitmap)->image.type = ImageTypeBitmap;
1840 memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1841 (*bitmap)->image.flags = ImageFlagsNone;
1842 (*bitmap)->image.frame_count = 1;
1843 (*bitmap)->image.current_frame = 0;
1844 (*bitmap)->image.palette = NULL;
1845 (*bitmap)->image.xres = xres;
1846 (*bitmap)->image.yres = yres;
1847 (*bitmap)->width = width;
1848 (*bitmap)->height = height;
1849 (*bitmap)->format = format;
1850 (*bitmap)->image.decoder = NULL;
1851 (*bitmap)->hbitmap = hbitmap;
1852 (*bitmap)->hdc = NULL;
1853 (*bitmap)->bits = bits;
1854 (*bitmap)->stride = stride;
1855 (*bitmap)->own_bits = own_bits;
1856 (*bitmap)->metadata_reader = NULL;
1857 (*bitmap)->prop_count = 0;
1858 (*bitmap)->prop_item = NULL;
1859
1860 /* set format-related flags */
1861 if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
1862 (*bitmap)->image.flags |= ImageFlagsHasAlpha;
1863
1864 if (format == PixelFormat1bppIndexed ||
1865 format == PixelFormat4bppIndexed ||
1866 format == PixelFormat8bppIndexed)
1867 {
1868 (*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
1869
1870 if (!(*bitmap)->image.palette)
1871 {
1872 GdipDisposeImage(&(*bitmap)->image);
1873 *bitmap = NULL;
1874 return OutOfMemory;
1875 }
1876
1877 (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
1878
1879 if (format == PixelFormat1bppIndexed)
1880 {
1881 (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
1882 (*bitmap)->image.palette->Entries[0] = 0xff000000;
1883 (*bitmap)->image.palette->Entries[1] = 0xffffffff;
1884 }
1885 else
1886 {
1887 if (format == PixelFormat8bppIndexed)
1888 (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
1889
1890 generate_halftone_palette((*bitmap)->image.palette->Entries,
1891 (*bitmap)->image.palette->Count);
1892 }
1893 }
1894
1895 TRACE("<-- %p\n", *bitmap);
1896
1897 return Ok;
1898 }
1899
1900 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1901 GpBitmap **bitmap)
1902 {
1903 GpStatus stat;
1904
1905 TRACE("%p %p\n", stream, bitmap);
1906
1907 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1908
1909 if(stat != Ok)
1910 return stat;
1911
1912 if((*bitmap)->image.type != ImageTypeBitmap){
1913 GdipDisposeImage(&(*bitmap)->image);
1914 *bitmap = NULL;
1915 return GenericError; /* FIXME: what error to return? */
1916 }
1917
1918 return Ok;
1919 }
1920
1921 /* FIXME: no icm */
1922 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1923 GpBitmap **bitmap)
1924 {
1925 TRACE("%p %p\n", stream, bitmap);
1926
1927 return GdipCreateBitmapFromStream(stream, bitmap);
1928 }
1929
1930 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1931 GpCachedBitmap **cachedbmp)
1932 {
1933 GpStatus stat;
1934
1935 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1936
1937 if(!bitmap || !graphics || !cachedbmp)
1938 return InvalidParameter;
1939
1940 *cachedbmp = heap_alloc_zero(sizeof(GpCachedBitmap));
1941 if(!*cachedbmp)
1942 return OutOfMemory;
1943
1944 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1945 if(stat != Ok){
1946 heap_free(*cachedbmp);
1947 return stat;
1948 }
1949
1950 return Ok;
1951 }
1952
1953 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1954 {
1955 GpStatus stat;
1956 BitmapData lockeddata;
1957 ULONG andstride, xorstride, bitssize;
1958 LPBYTE andbits, xorbits, androw, xorrow, srcrow;
1959 UINT x, y;
1960
1961 TRACE("(%p, %p)\n", bitmap, hicon);
1962
1963 if (!bitmap || !hicon)
1964 return InvalidParameter;
1965
1966 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
1967 PixelFormat32bppPARGB, &lockeddata);
1968 if (stat == Ok)
1969 {
1970 andstride = ((lockeddata.Width+31)/32)*4;
1971 xorstride = lockeddata.Width*4;
1972 bitssize = (andstride + xorstride) * lockeddata.Height;
1973
1974 andbits = heap_alloc_zero(bitssize);
1975
1976 if (andbits)
1977 {
1978 xorbits = andbits + andstride * lockeddata.Height;
1979
1980 for (y=0; y<lockeddata.Height; y++)
1981 {
1982 srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
1983
1984 androw = andbits + andstride * y;
1985 for (x=0; x<lockeddata.Width; x++)
1986 if (srcrow[3+4*x] >= 128)
1987 androw[x/8] |= 1 << (7-x%8);
1988
1989 xorrow = xorbits + xorstride * y;
1990 memcpy(xorrow, srcrow, xorstride);
1991 }
1992
1993 *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
1994 andbits, xorbits);
1995
1996 heap_free(andbits);
1997 }
1998 else
1999 stat = OutOfMemory;
2000
2001 GdipBitmapUnlockBits(bitmap, &lockeddata);
2002 }
2003
2004 return stat;
2005 }
2006
2007 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
2008 {
2009 TRACE("%p\n", cachedbmp);
2010
2011 if(!cachedbmp)
2012 return InvalidParameter;
2013
2014 GdipDisposeImage(cachedbmp->image);
2015 heap_free(cachedbmp);
2016
2017 return Ok;
2018 }
2019
2020 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
2021 GpCachedBitmap *cachedbmp, INT x, INT y)
2022 {
2023 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
2024
2025 if(!graphics || !cachedbmp)
2026 return InvalidParameter;
2027
2028 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
2029 }
2030
2031 /* Internal utility function: Replace the image data of dst with that of src,
2032 * and free src. */
2033 static void move_bitmap(GpBitmap *dst, GpBitmap *src, BOOL clobber_palette)
2034 {
2035 assert(src->image.type == ImageTypeBitmap);
2036 assert(dst->image.type == ImageTypeBitmap);
2037
2038 heap_free(dst->bitmapbits);
2039 heap_free(dst->own_bits);
2040 DeleteDC(dst->hdc);
2041 DeleteObject(dst->hbitmap);
2042
2043 if (clobber_palette)
2044 {
2045 heap_free(dst->image.palette);
2046 dst->image.palette = src->image.palette;
2047 }
2048 else
2049 heap_free(src->image.palette);
2050
2051 dst->image.xres = src->image.xres;
2052 dst->image.yres = src->image.yres;
2053 dst->width = src->width;
2054 dst->height = src->height;
2055 dst->format = src->format;
2056 dst->hbitmap = src->hbitmap;
2057 dst->hdc = src->hdc;
2058 dst->bits = src->bits;
2059 dst->stride = src->stride;
2060 dst->own_bits = src->own_bits;
2061 if (dst->metadata_reader)
2062 IWICMetadataReader_Release(dst->metadata_reader);
2063 dst->metadata_reader = src->metadata_reader;
2064 heap_free(dst->prop_item);
2065 dst->prop_item = src->prop_item;
2066 dst->prop_count = src->prop_count;
2067 if (dst->image.decoder)
2068 IWICBitmapDecoder_Release(dst->image.decoder);
2069 dst->image.decoder = src->image.decoder;
2070 dst->image.frame_count = src->image.frame_count;
2071 dst->image.current_frame = src->image.current_frame;
2072 dst->image.format = src->image.format;
2073
2074 src->image.type = ~0;
2075 heap_free(src);
2076 }
2077
2078 static GpStatus free_image_data(GpImage *image)
2079 {
2080 if(!image)
2081 return InvalidParameter;
2082
2083 if (image->type == ImageTypeBitmap)
2084 {
2085 heap_free(((GpBitmap*)image)->bitmapbits);
2086 heap_free(((GpBitmap*)image)->own_bits);
2087 DeleteDC(((GpBitmap*)image)->hdc);
2088 DeleteObject(((GpBitmap*)image)->hbitmap);
2089 if (((GpBitmap*)image)->metadata_reader)
2090 IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2091 heap_free(((GpBitmap*)image)->prop_item);
2092 }
2093 else if (image->type == ImageTypeMetafile)
2094 METAFILE_Free((GpMetafile *)image);
2095 else
2096 {
2097 WARN("invalid image: %p\n", image);
2098 return ObjectBusy;
2099 }
2100 if (image->decoder)
2101 IWICBitmapDecoder_Release(image->decoder);
2102 heap_free(image->palette);
2103
2104 return Ok;
2105 }
2106
2107 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2108 {
2109 GpStatus status;
2110
2111 TRACE("%p\n", image);
2112
2113 status = free_image_data(image);
2114 if (status != Ok) return status;
2115 image->type = ~0;
2116 heap_free(image);
2117
2118 return Ok;
2119 }
2120
2121 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2122 {
2123 static int calls;
2124
2125 TRACE("(%p,%p)\n", image, item);
2126
2127 if(!image || !item)
2128 return InvalidParameter;
2129
2130 if (!(calls++))
2131 FIXME("not implemented\n");
2132
2133 return NotImplemented;
2134 }
2135
2136 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2137 {
2138 static int calls;
2139
2140 TRACE("(%p,%p)\n", image, item);
2141
2142 if (!(calls++))
2143 FIXME("not implemented\n");
2144
2145 return NotImplemented;
2146 }
2147
2148 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2149 GpUnit *srcUnit)
2150 {
2151 TRACE("%p %p %p\n", image, srcRect, srcUnit);
2152
2153 if(!image || !srcRect || !srcUnit)
2154 return InvalidParameter;
2155 if(image->type == ImageTypeMetafile){
2156 *srcRect = ((GpMetafile*)image)->bounds;
2157 *srcUnit = ((GpMetafile*)image)->unit;
2158 }
2159 else if(image->type == ImageTypeBitmap){
2160 srcRect->X = srcRect->Y = 0.0;
2161 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2162 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2163 *srcUnit = UnitPixel;
2164 }
2165 else{
2166 WARN("GpImage with no image data\n");
2167 return InvalidParameter;
2168 }
2169
2170 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2171 srcRect->Width, srcRect->Height, *srcUnit);
2172
2173 return Ok;
2174 }
2175
2176 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2177 REAL *height)
2178 {
2179 TRACE("%p %p %p\n", image, width, height);
2180
2181 if(!image || !height || !width)
2182 return InvalidParameter;
2183
2184 if(image->type == ImageTypeMetafile){
2185 *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2186 *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2187 }
2188 else if(image->type == ImageTypeBitmap){
2189 *height = ((GpBitmap*)image)->height;
2190 *width = ((GpBitmap*)image)->width;
2191 }
2192 else{
2193 WARN("GpImage with no image data\n");
2194 return InvalidParameter;
2195 }
2196
2197 TRACE("returning (%f, %f)\n", *height, *width);
2198 return Ok;
2199 }
2200
2201 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2202 GpGraphics **graphics)
2203 {
2204 HDC hdc;
2205 GpStatus stat;
2206
2207 TRACE("%p %p\n", image, graphics);
2208
2209 if(!image || !graphics)
2210 return InvalidParameter;
2211
2212 if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2213 {
2214 hdc = ((GpBitmap*)image)->hdc;
2215
2216 if(!hdc){
2217 hdc = CreateCompatibleDC(0);
2218 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2219 ((GpBitmap*)image)->hdc = hdc;
2220 }
2221
2222 stat = GdipCreateFromHDC(hdc, graphics);
2223
2224 if (stat == Ok)
2225 {
2226 (*graphics)->image = image;
2227 (*graphics)->xres = image->xres;
2228 (*graphics)->yres = image->yres;
2229 }
2230 }
2231 else if (image->type == ImageTypeMetafile)
2232 stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2233 else
2234 stat = graphics_from_image(image, graphics);
2235
2236 return stat;
2237 }
2238
2239 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2240 {
2241 TRACE("%p %p\n", image, height);
2242
2243 if(!image || !height)
2244 return InvalidParameter;
2245
2246 if(image->type == ImageTypeMetafile)
2247 *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2248 else if(image->type == ImageTypeBitmap)
2249 *height = ((GpBitmap*)image)->height;
2250 else
2251 {
2252 WARN("GpImage with no image data\n");
2253 return InvalidParameter;
2254 }
2255
2256 TRACE("returning %d\n", *height);
2257
2258 return Ok;
2259 }
2260
2261 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2262 {
2263 if(!image || !res)
2264 return InvalidParameter;
2265
2266 *res = image->xres;
2267
2268 TRACE("(%p) <-- %0.2f\n", image, *res);
2269
2270 return Ok;
2271 }
2272
2273 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2274 {
2275 TRACE("%p %p\n", image, size);
2276
2277 if(!image || !size)
2278 return InvalidParameter;
2279
2280 if (!image->palette || image->palette->Count == 0)
2281 *size = sizeof(ColorPalette);
2282 else
2283 *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
2284
2285 TRACE("<-- %u\n", *size);
2286
2287 return Ok;
2288 }
2289
2290 /* FIXME: test this function for non-bitmap types */
2291 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2292 {
2293 TRACE("%p %p\n", image, format);
2294
2295 if(!image || !format)
2296 return InvalidParameter;
2297
2298 if(image->type != ImageTypeBitmap)
2299 *format = PixelFormat24bppRGB;
2300 else
2301 *format = ((GpBitmap*) image)->format;
2302
2303 return Ok;
2304 }
2305
2306 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2307 {
2308 TRACE("(%p, %p)\n", image, format);
2309
2310 if(!image || !format)
2311 return InvalidParameter;
2312
2313 memcpy(format, &image->format, sizeof(GUID));
2314
2315 return Ok;
2316 }
2317
2318 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2319 {
2320 TRACE("%p %p\n", image, type);
2321
2322 if(!image || !type)
2323 return InvalidParameter;
2324
2325 *type = image->type;
2326
2327 return Ok;
2328 }
2329
2330 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2331 {
2332 if(!image || !res)
2333 return InvalidParameter;
2334
2335 *res = image->yres;
2336
2337 TRACE("(%p) <-- %0.2f\n", image, *res);
2338
2339 return Ok;
2340 }
2341
2342 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2343 {
2344 TRACE("%p %p\n", image, width);
2345
2346 if(!image || !width)
2347 return InvalidParameter;
2348
2349 if(image->type == ImageTypeMetafile)
2350 *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2351 else if(image->type == ImageTypeBitmap)
2352 *width = ((GpBitmap*)image)->width;
2353 else
2354 {
2355 WARN("GpImage with no image data\n");
2356 return InvalidParameter;
2357 }
2358
2359 TRACE("returning %d\n", *width);
2360
2361 return Ok;
2362 }
2363
2364 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2365 {
2366 TRACE("(%p, %p)\n", image, num);
2367
2368 if (!image || !num) return InvalidParameter;
2369
2370 *num = 0;
2371
2372 if (image->type == ImageTypeBitmap)
2373 {
2374 if (((GpBitmap *)image)->prop_item)
2375 {
2376 *num = ((GpBitmap *)image)->prop_count;
2377 return Ok;
2378 }
2379
2380 if (((GpBitmap *)image)->metadata_reader)
2381 IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2382 }
2383
2384 return Ok;
2385 }
2386
2387 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2388 {
2389 HRESULT hr;
2390 IWICMetadataReader *reader;
2391 IWICEnumMetadataItem *enumerator;
2392 UINT prop_count, i, items_returned;
2393
2394 TRACE("(%p, %u, %p)\n", image, num, list);
2395
2396 if (!image || !list) return InvalidParameter;
2397
2398 if (image->type != ImageTypeBitmap)
2399 {
2400 FIXME("Not implemented for type %d\n", image->type);
2401 return NotImplemented;
2402 }
2403
2404 if (((GpBitmap *)image)->prop_item)
2405 {
2406 if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
2407
2408 for (i = 0; i < num; i++)
2409 {
2410 list[i] = ((GpBitmap *)image)->prop_item[i].id;
2411 }
2412
2413 return Ok;
2414 }
2415
2416 reader = ((GpBitmap *)image)->metadata_reader;
2417 if (!reader)
2418 {
2419 if (num != 0) return InvalidParameter;
2420 return Ok;
2421 }
2422
2423 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2424 if (FAILED(hr)) return hresult_to_status(hr);
2425
2426 if (num != prop_count) return InvalidParameter;
2427
2428 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2429 if (FAILED(hr)) return hresult_to_status(hr);
2430
2431 IWICEnumMetadataItem_Reset(enumerator);
2432
2433 for (i = 0; i < num; i++)
2434 {
2435 PROPVARIANT id;
2436
2437 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2438 if (hr != S_OK) break;
2439
2440 if (id.vt != VT_UI2)
2441 {
2442 FIXME("not supported propvariant type for id: %u\n", id.vt);
2443 list[i] = 0;
2444 continue;
2445 }
2446 list[i] = id.u.uiVal;
2447 }
2448
2449 IWICEnumMetadataItem_Release(enumerator);
2450
2451 return hr == S_OK ? Ok : hresult_to_status(hr);
2452 }
2453
2454 static UINT propvariant_size(PROPVARIANT *value)
2455 {
2456 switch (value->vt & ~VT_VECTOR)
2457 {
2458 case VT_EMPTY:
2459 return 0;
2460 case VT_I1:
2461 case VT_UI1:
2462 if (!(value->vt & VT_VECTOR)) return 1;
2463 return value->u.caub.cElems;
2464 case VT_I2:
2465 case VT_UI2:
2466 if (!(value->vt & VT_VECTOR)) return 2;
2467 return value->u.caui.cElems * 2;
2468 case VT_I4:
2469 case VT_UI4:
2470 case VT_R4:
2471 if (!(value->vt & VT_VECTOR)) return 4;
2472 return value->u.caul.cElems * 4;
2473 case VT_I8:
2474 case VT_UI8:
2475 case VT_R8:
2476 if (!(value->vt & VT_VECTOR)) return 8;
2477 return value->u.cauh.cElems * 8;
2478 case VT_LPSTR:
2479 return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2480 case VT_BLOB:
2481 return value->u.blob.cbSize;
2482 default:
2483 FIXME("not supported variant type %d\n", value->vt);
2484 return 0;
2485 }
2486 }
2487
2488 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2489 {
2490 HRESULT hr;
2491 IWICMetadataReader *reader;
2492 PROPVARIANT id, value;
2493
2494 TRACE("(%p,%#x,%p)\n", image, propid, size);
2495
2496 if (!size || !image) return InvalidParameter;
2497
2498 if (image->type != ImageTypeBitmap)
2499 {
2500 FIXME("Not implemented for type %d\n", image->type);
2501 return NotImplemented;
2502 }
2503
2504 if (((GpBitmap *)image)->prop_item)
2505 {
2506 UINT i;
2507
2508 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2509 {
2510 if (propid == ((GpBitmap *)image)->prop_item[i].id)
2511 {
2512 *size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2513 return Ok;
2514 }
2515 }
2516
2517 return PropertyNotFound;
2518 }
2519
2520 reader = ((GpBitmap *)image)->metadata_reader;
2521 if (!reader) return PropertyNotFound;
2522
2523 id.vt = VT_UI2;
2524 id.u.uiVal = propid;
2525 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2526 if (FAILED(hr)) return PropertyNotFound;
2527
2528 *size = propvariant_size(&value);
2529 if (*size) *size += sizeof(PropertyItem);
2530 PropVariantClear(&value);
2531
2532 return Ok;
2533 }
2534
2535 #ifndef PropertyTagTypeSByte
2536 #define PropertyTagTypeSByte 6
2537 #define PropertyTagTypeSShort 8
2538 #define PropertyTagTypeFloat 11
2539 #define PropertyTagTypeDouble 12
2540 #endif
2541
2542 static UINT vt_to_itemtype(UINT vt)
2543 {
2544 static const struct
2545 {
2546 UINT vt, type;
2547 } vt2type[] =
2548 {
2549 { VT_I1, PropertyTagTypeSByte },
2550 { VT_UI1, PropertyTagTypeByte },
2551 { VT_I2, PropertyTagTypeSShort },
2552 { VT_UI2, PropertyTagTypeShort },
2553 { VT_I4, PropertyTagTypeSLONG },
2554 { VT_UI4, PropertyTagTypeLong },
2555 { VT_I8, PropertyTagTypeSRational },
2556 { VT_UI8, PropertyTagTypeRational },
2557 { VT_R4, PropertyTagTypeFloat },
2558 { VT_R8, PropertyTagTypeDouble },
2559 { VT_LPSTR, PropertyTagTypeASCII },
2560 { VT_BLOB, PropertyTagTypeUndefined }
2561 };
2562 UINT i;
2563 for (i = 0; i < ARRAY_SIZE(vt2type); i++)
2564 {
2565 if (vt2type[i].vt == vt) return vt2type[i].type;
2566 }
2567 FIXME("not supported variant type %u\n", vt);
2568 return 0;
2569 }
2570
2571 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2572 UINT size, PROPID id)
2573 {
2574 UINT item_size, item_type;
2575
2576 item_size = propvariant_size(value);
2577 if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2578
2579 item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2580 if (!item_type) return InvalidParameter;
2581
2582 item->value = item + 1;
2583
2584 switch (value->vt & ~VT_VECTOR)
2585 {
2586 case VT_I1:
2587 case VT_UI1:
2588 if (!(value->vt & VT_VECTOR))
2589 *(BYTE *)item->value = value->u.bVal;
2590 else
2591 memcpy(item->value, value->u.caub.pElems, item_size);
2592 break;
2593 case VT_I2:
2594 case VT_UI2:
2595 if (!(value->vt & VT_VECTOR))
2596 *(USHORT *)item->value = value->u.uiVal;
2597 else
2598 memcpy(item->value, value->u.caui.pElems, item_size);
2599 break;
2600 case VT_I4:
2601 case VT_UI4:
2602 case VT_R4:
2603 if (!(value->vt & VT_VECTOR))
2604 *(ULONG *)item->value = value->u.ulVal;
2605 else
2606 memcpy(item->value, value->u.caul.pElems, item_size);
2607 break;
2608 case VT_I8:
2609 case VT_UI8:
2610 case VT_R8:
2611 if (!(value->vt & VT_VECTOR))
2612 *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2613 else
2614 memcpy(item->value, value->u.cauh.pElems, item_size);
2615 break;
2616 case VT_LPSTR:
2617 memcpy(item->value, value->u.pszVal, item_size);
2618 break;
2619 case VT_BLOB:
2620 memcpy(item->value, value->u.blob.pBlobData, item_size);
2621 break;
2622 default:
2623 FIXME("not supported variant type %d\n", value->vt);
2624 return InvalidParameter;
2625 }
2626
2627 item->length = item_size;
2628 item->type = item_type;
2629 item->id = id;
2630
2631 return Ok;
2632 }
2633
2634 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2635 PropertyItem *buffer)
2636 {
2637 GpStatus stat;
2638 HRESULT hr;
2639 IWICMetadataReader *reader;
2640 PROPVARIANT id, value;
2641
2642 TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2643
2644 if (!image || !buffer) return InvalidParameter;
2645
2646 if (image->type != ImageTypeBitmap)
2647 {
2648 FIXME("Not implemented for type %d\n", image->type);
2649 return NotImplemented;
2650 }
2651
2652 if (((GpBitmap *)image)->prop_item)
2653 {
2654 UINT i;
2655
2656 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2657 {
2658 if (propid == ((GpBitmap *)image)->prop_item[i].id)
2659 {
2660 if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
2661 return InvalidParameter;
2662
2663 *buffer = ((GpBitmap *)image)->prop_item[i];
2664 buffer->value = buffer + 1;
2665 memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
2666 return Ok;
2667 }
2668 }
2669
2670 return PropertyNotFound;
2671 }
2672
2673 reader = ((GpBitmap *)image)->metadata_reader;
2674 if (!reader) return PropertyNotFound;
2675
2676 id.vt = VT_UI2;
2677 id.u.uiVal = propid;
2678 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2679 if (FAILED(hr)) return PropertyNotFound;
2680
2681 stat = propvariant_to_item(&value, buffer, size, propid);
2682 PropVariantClear(&value);
2683
2684 return stat;
2685 }
2686
2687 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2688 {
2689 HRESULT hr;
2690 IWICMetadataReader *reader;
2691 IWICEnumMetadataItem *enumerator;
2692 UINT prop_count, prop_size, i;
2693 PROPVARIANT id, value;
2694
2695 TRACE("(%p,%p,%p)\n", image, size, count);
2696
2697 if (!image || !size || !count) return InvalidParameter;
2698
2699 if (image->type != ImageTypeBitmap)
2700 {
2701 FIXME("Not implemented for type %d\n", image->type);
2702 return NotImplemented;
2703 }
2704
2705 if (((GpBitmap *)image)->prop_item)
2706 {
2707 *count = ((GpBitmap *)image)->prop_count;
2708 *size = 0;
2709
2710 for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2711 {
2712 *size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2713 }
2714
2715 return Ok;
2716 }
2717
2718 reader = ((GpBitmap *)image)->metadata_reader;
2719 if (!reader) return PropertyNotFound;
2720
2721 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2722 if (FAILED(hr)) return hresult_to_status(hr);
2723
2724 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2725 if (FAILED(hr)) return hresult_to_status(hr);
2726
2727 IWICEnumMetadataItem_Reset(enumerator);
2728
2729 prop_size = 0;
2730
2731 PropVariantInit(&id);
2732 PropVariantInit(&value);
2733
2734 for (i = 0; i < prop_count; i++)
2735 {
2736 UINT items_returned, item_size;
2737
2738 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2739 if (hr != S_OK) break;
2740
2741 item_size = propvariant_size(&value);
2742 if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2743
2744 PropVariantClear(&id);
2745 PropVariantClear(&value);
2746 }
2747
2748 IWICEnumMetadataItem_Release(enumerator);
2749
2750 if (hr != S_OK) return PropertyNotFound;
2751
2752 *count = prop_count;
2753 *size = prop_size;
2754 return Ok;
2755 }
2756
2757 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2758 UINT count, PropertyItem *buf)
2759 {
2760 GpStatus status;
2761 HRESULT hr;
2762 IWICMetadataReader *reader;
2763 IWICEnumMetadataItem *enumerator;
2764 UINT prop_count, prop_size, i;
2765 PROPVARIANT id, value;
2766 char *item_value;
2767
2768 TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2769
2770 if (!image || !buf) return InvalidParameter;
2771
2772 if (image->type != ImageTypeBitmap)
2773 {
2774 FIXME("Not implemented for type %d\n", image->type);
2775 return NotImplemented;
2776 }
2777
2778 status = GdipGetPropertySize(image, &prop_size, &prop_count);
2779 if (status != Ok) return status;
2780
2781 if (prop_count != count || prop_size != size) return InvalidParameter;
2782
2783 if (((GpBitmap *)image)->prop_item)
2784 {
2785 memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
2786
2787 item_value = (char *)(buf + prop_count);
2788
2789 for (i = 0; i < prop_count; i++)
2790 {
2791 buf[i].value = item_value;
2792 item_value += buf[i].length;
2793 }
2794
2795 return Ok;
2796 }
2797
2798 reader = ((GpBitmap *)image)->metadata_reader;
2799 if (!reader) return PropertyNotFound;
2800
2801 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2802 if (FAILED(hr)) return hresult_to_status(hr);
2803
2804 IWICEnumMetadataItem_Reset(enumerator);
2805
2806 item_value = (char *)(buf + prop_count);
2807
2808 PropVariantInit(&id);
2809 PropVariantInit(&value);
2810
2811 for (i = 0; i < prop_count; i++)
2812 {
2813 PropertyItem *item;
2814 UINT items_returned, item_size;
2815
2816 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2817 if (hr != S_OK) break;
2818
2819 if (id.vt != VT_UI2)
2820 {
2821 FIXME("not supported propvariant type for id: %u\n", id.vt);
2822 continue;
2823 }
2824
2825 item_size = propvariant_size(&value);
2826 if (item_size)
2827 {
2828 item = heap_alloc(item_size + sizeof(*item));
2829
2830 propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2831 buf[i].id = item->id;
2832 buf[i].type = item->type;
2833 buf[i].length = item_size;
2834 buf[i].value = item_value;
2835 memcpy(item_value, item->value, item_size);
2836 item_value += item_size;
2837
2838 heap_free(item);
2839 }
2840
2841 PropVariantClear(&id);
2842 PropVariantClear(&value);
2843 }
2844
2845 IWICEnumMetadataItem_Release(enumerator);
2846
2847 if (hr != S_OK) return PropertyNotFound;
2848
2849 return Ok;
2850 }
2851
2852 struct image_format_dimension
2853 {
2854 const GUID *format;
2855 const GUID *dimension;
2856 };
2857
2858 static const struct image_format_dimension image_format_dimensions[] =
2859 {
2860 {&ImageFormatGIF, &FrameDimensionTime},
2861 {&ImageFormatIcon, &FrameDimensionResolution},
2862 {NULL}
2863 };
2864
2865 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2866 GDIPCONST GUID* dimensionID, UINT* count)
2867 {
2868 TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2869
2870 if(!image || !count)
2871 return InvalidParameter;
2872
2873 if (!dimensionID ||
2874 IsEqualGUID(dimensionID, &image->format) ||
2875 IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2876 IsEqualGUID(dimensionID, &FrameDimensionTime))
2877 {
2878 *count = image->frame_count;
2879 return Ok;
2880 }
2881
2882 return InvalidParameter;
2883 }
2884
2885 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2886 UINT* count)
2887 {
2888 TRACE("(%p, %p)\n", image, count);
2889
2890 /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2891
2892 if(!image || !count)
2893 return InvalidParameter;
2894
2895 *count = 1;
2896
2897 return Ok;
2898 }
2899
2900 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2901 GUID* dimensionIDs, UINT count)
2902 {
2903 int i;
2904 const GUID *result=NULL;
2905
2906 TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2907
2908 if(!image || !dimensionIDs || count != 1)
2909 return InvalidParameter;
2910
2911 for (i=0; image_format_dimensions[i].format; i++)
2912 {
2913 if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2914 {
2915 result = image_format_dimensions[i].dimension;
2916 break;
2917 }
2918 }
2919
2920 if (!result)
2921 result = &FrameDimensionPage;
2922
2923 memcpy(dimensionIDs, result, sizeof(GUID));
2924
2925 return Ok;
2926 }
2927
2928 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2929 GpImage **image)
2930 {
2931 GpStatus stat;
2932 IStream *stream;
2933
2934 TRACE("(%s) %p\n", debugstr_w(filename), image);
2935
2936 if (!filename || !image)
2937 return InvalidParameter;
2938
2939 *image = NULL;
2940
2941 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2942
2943 if (stat != Ok)
2944 return stat;
2945
2946 stat = GdipLoadImageFromStream(stream, image);
2947
2948 IStream_Release(stream);
2949
2950 return stat;
2951 }
2952
2953 /* FIXME: no icm handling */
2954 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2955 {
2956 TRACE("(%s) %p\n", debugstr_w(filename), image);
2957
2958 return GdipLoadImageFromFile(filename, image);
2959 }
2960
2961 static void add_property(GpBitmap *bitmap, PropertyItem *item)
2962 {
2963 UINT prop_size, prop_count;
2964 PropertyItem *prop_item;
2965
2966 if (bitmap->prop_item == NULL)
2967 {
2968 prop_size = prop_count = 0;
2969 prop_item = heap_alloc_zero(item->length + sizeof(PropertyItem));
2970 if (!prop_item) return;
2971 }
2972 else
2973 {
2974 UINT i;
2975 char *item_value;
2976
2977 GdipGetPropertySize(&bitmap->image, &prop_size, &prop_count);
2978
2979 prop_item = heap_alloc_zero(prop_size + item->length + sizeof(PropertyItem));
2980 if (!prop_item) return;
2981 memcpy(prop_item, bitmap->prop_item, sizeof(PropertyItem) * bitmap->prop_count);
2982 prop_size -= sizeof(PropertyItem) * bitmap->prop_count;
2983 memcpy(prop_item + prop_count + 1, bitmap->prop_item + prop_count, prop_size);
2984
2985 item_value = (char *)(prop_item + prop_count + 1);
2986
2987 for (i = 0; i < prop_count; i++)
2988 {
2989 prop_item[i].value = item_value;
2990 item_value += prop_item[i].length;
2991 }
2992 }
2993
2994 prop_item[prop_count].id = item->id;
2995 prop_item[prop_count].type = item->type;
2996 prop_item[prop_count].length = item->length;
2997 prop_item[prop_count].value = (char *)(prop_item + prop_count + 1) + prop_size;
2998 memcpy(prop_item[prop_count].value, item->value, item->length);
2999
3000 heap_free(bitmap->prop_item);
3001 bitmap->prop_item = prop_item;
3002 bitmap->prop_count++;
3003 }
3004
3005 static BOOL get_bool_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3006 {
3007 HRESULT hr;
3008 GUID format;
3009 PROPVARIANT id, value;
3010 BOOL ret = FALSE;
3011
3012 hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3013 if (FAILED(hr) || !IsEqualGUID(&format, guid)) return FALSE;
3014
3015 PropVariantInit(&id);
3016 PropVariantInit(&value);
3017
3018 id.vt = VT_LPWSTR;
3019 id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3020 if (!id.u.pwszVal) return FALSE;
3021 lstrcpyW(id.u.pwszVal, prop_name);
3022 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3023 if (hr == S_OK && value.vt == VT_BOOL)
3024 ret = value.u.boolVal;
3025
3026 PropVariantClear(&id);
3027 PropVariantClear(&value);
3028
3029 return ret;
3030 }
3031
3032 static PropertyItem *get_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3033 {
3034 HRESULT hr;
3035 GUID format;
3036 PROPVARIANT id, value;
3037 PropertyItem *item = NULL;
3038
3039 hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3040 if (FAILED(hr) || !IsEqualGUID(&format, guid)) return NULL;
3041
3042 PropVariantInit(&id);
3043 PropVariantInit(&value);
3044
3045 id.vt = VT_LPWSTR;
3046 id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3047 if (!id.u.pwszVal) return NULL;
3048 lstrcpyW(id.u.pwszVal, prop_name);
3049 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3050 if (hr == S_OK)
3051 {
3052 UINT item_size = propvariant_size(&value);
3053 if (item_size)
3054 {
3055 item_size += sizeof(*item);
3056 item = heap_alloc_zero(item_size);
3057 if (propvariant_to_item(&value, item, item_size, 0) != Ok)
3058 {
3059 heap_free(item);
3060 item = NULL;
3061 }
3062 }
3063 }
3064
3065 PropVariantClear(&id);
3066 PropVariantClear(&value);
3067
3068 return item;
3069 }
3070
3071 static PropertyItem *get_gif_comment(IWICMetadataReader *reader)
3072 {
3073 static const WCHAR textentryW[] = { 'T','e','x','t','E','n','t','r','y',0 };
3074 PropertyItem *comment;
3075
3076 comment = get_property(reader, &GUID_MetadataFormatGifComment, textentryW);
3077 if (comment)
3078 comment->id = PropertyTagExifUserComment;
3079
3080 return comment;
3081 }
3082
3083 static PropertyItem *get_gif_loopcount(IWICMetadataReader *reader)
3084 {
3085 static const WCHAR applicationW[] = { 'A','p','p','l','i','c','a','t','i','o','n',0 };
3086 static const WCHAR dataW[] = { 'D','a','t','a',0 };
3087 PropertyItem *appext = NULL, *appdata = NULL, *loop = NULL;
3088
3089 appext = get_property(reader, &GUID_MetadataFormatAPE, applicationW);
3090 if (appext)
3091 {
3092 if (appext->type == PropertyTagTypeByte && appext->length == 11 &&
3093 (!memcmp(appext->value, "NETSCAPE2.0", 11) || !memcmp(appext->value, "ANIMEXTS1.0", 11)))
3094 {
3095 appdata = get_property(reader, &GUID_MetadataFormatAPE, dataW);
3096 if (appdata)
3097 {
3098 if (appdata->type == PropertyTagTypeByte && appdata->length == 4)
3099 {
3100 BYTE *data = appdata->value;
3101 if (data[0] == 3 && data[1] == 1)
3102 {
3103 loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
3104 if (loop)
3105 {
3106 loop->type = PropertyTagTypeShort;
3107 loop->id = PropertyTagLoopCount;
3108 loop->length = sizeof(SHORT);
3109 loop->value = loop + 1;
3110 *(SHORT *)loop->value = data[2] | (data[3] << 8);
3111 }
3112 }
3113 }
3114 }
3115 }
3116 }
3117
3118 heap_free(appext);
3119 heap_free(appdata);
3120
3121 return loop;
3122 }
3123
3124 static PropertyItem *get_gif_background(IWICMetadataReader *reader)
3125 {
3126 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 };
3127 PropertyItem *background;
3128
3129 background = get_property(reader, &GUID_MetadataFormatLSD, backgroundW);
3130 if (background)
3131 background->id = PropertyTagIndexBackground;
3132
3133 return background;
3134 }
3135
3136 static PropertyItem *get_gif_palette(IWICBitmapDecoder *decoder, IWICMetadataReader *reader)
3137 {