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