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