?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Increase refcount of the source stream when loading a bitmap instead of...
[wine/multimedia.git] / dlls / gdiplus / image.c
blobe676a4ef91447450179beafc947d990a8cd5b1fd
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 assert(src->image.stream == NULL);
1975 assert(dst->image.stream == NULL);
1976
1977 GdipFree(dst->bitmapbits);
1978 DeleteDC(dst->hdc);
1979 DeleteObject(dst->hbitmap);
1980
1981 if (clobber_palette)
1982 {
1983 GdipFree(dst->image.palette_entries);
1984 dst->image.palette_flags = src->image.palette_flags;
1985 dst->image.palette_count = src->image.palette_count;
1986 dst->image.palette_entries = src->image.palette_entries;
1987 }
1988 else
1989 GdipFree(src->image.palette_entries);
1990
1991 dst->image.xres = src->image.xres;
1992 dst->image.yres = src->image.yres;
1993 dst->width = src->width;
1994 dst->height = src->height;
1995 dst->format = src->format;
1996 dst->hbitmap = src->hbitmap;
1997 dst->hdc = src->hdc;
1998 dst->bits = src->bits;
1999 dst->stride = src->stride;
2000 dst->own_bits = src->own_bits;
2001 if (dst->metadata_reader)
2002 IWICMetadataReader_Release(dst->metadata_reader);
2003 dst->metadata_reader = src->metadata_reader;
2004
2005 src->image.type = ~0;
2006 GdipFree(src);
2007 }
2008
2009 static GpStatus free_image_data(GpImage *image)
2010 {
2011 if(!image)
2012 return InvalidParameter;
2013
2014 if (image->type == ImageTypeBitmap)
2015 {
2016 GdipFree(((GpBitmap*)image)->bitmapbits);
2017 GdipFree(((GpBitmap*)image)->own_bits);
2018 DeleteDC(((GpBitmap*)image)->hdc);
2019 DeleteObject(((GpBitmap*)image)->hbitmap);
2020 if (((GpBitmap*)image)->metadata_reader)
2021 IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2022 }
2023 else if (image->type == ImageTypeMetafile)
2024 {
2025 GpMetafile *metafile = (GpMetafile*)image;
2026 GdipFree(metafile->comment_data);
2027 DeleteEnhMetaFile(CloseEnhMetaFile(metafile->record_dc));
2028 DeleteEnhMetaFile(metafile->hemf);
2029 if (metafile->record_graphics)
2030 {
2031 WARN("metafile closed while recording\n");
2032 /* not sure what to do here; for now just prevent the graphics from functioning or using this object */
2033 metafile->record_graphics->image = NULL;
2034 metafile->record_graphics->busy = TRUE;
2035 }
2036 }
2037 else
2038 {
2039 WARN("invalid image: %p\n", image);
2040 return ObjectBusy;
2041 }
2042 if (image->picture)
2043 IPicture_Release(image->picture);
2044 if (image->stream)
2045 IStream_Release(image->stream);
2046 GdipFree(image->palette_entries);
2047
2048 return Ok;
2049 }
2050
2051 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2052 {
2053 GpStatus status;
2054
2055 TRACE("%p\n", image);
2056
2057 status = free_image_data(image);
2058 if (status != Ok) return status;
2059 image->type = ~0;
2060 GdipFree(image);
2061
2062 return Ok;
2063 }
2064
2065 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2066 {
2067 static int calls;
2068
2069 TRACE("(%p,%p)\n", image, item);
2070
2071 if(!image || !item)
2072 return InvalidParameter;
2073
2074 if (!(calls++))
2075 FIXME("not implemented\n");
2076
2077 return NotImplemented;
2078 }
2079
2080 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2081 {
2082 static int calls;
2083
2084 TRACE("(%p,%p)\n", image, item);
2085
2086 if (!(calls++))
2087 FIXME("not implemented\n");
2088
2089 return NotImplemented;
2090 }
2091
2092 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2093 GpUnit *srcUnit)
2094 {
2095 TRACE("%p %p %p\n", image, srcRect, srcUnit);
2096
2097 if(!image || !srcRect || !srcUnit)
2098 return InvalidParameter;
2099 if(image->type == ImageTypeMetafile){
2100 *srcRect = ((GpMetafile*)image)->bounds;
2101 *srcUnit = ((GpMetafile*)image)->unit;
2102 }
2103 else if(image->type == ImageTypeBitmap){
2104 srcRect->X = srcRect->Y = 0.0;
2105 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2106 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2107 *srcUnit = UnitPixel;
2108 }
2109 else{
2110 srcRect->X = srcRect->Y = 0.0;
2111 srcRect->Width = ipicture_pixel_width(image->picture);
2112 srcRect->Height = ipicture_pixel_height(image->picture);
2113 *srcUnit = UnitPixel;
2114 }
2115
2116 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2117 srcRect->Width, srcRect->Height, *srcUnit);
2118
2119 return Ok;
2120 }
2121
2122 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2123 REAL *height)
2124 {
2125 TRACE("%p %p %p\n", image, width, height);
2126
2127 if(!image || !height || !width)
2128 return InvalidParameter;
2129
2130 if(image->type == ImageTypeMetafile){
2131 HDC hdc = GetDC(0);
2132 REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2133
2134 ReleaseDC(0, hdc);
2135
2136 *height = convert_unit(res, ((GpMetafile*)image)->unit) *
2137 ((GpMetafile*)image)->bounds.Height;
2138
2139 *width = convert_unit(res, ((GpMetafile*)image)->unit) *
2140 ((GpMetafile*)image)->bounds.Width;
2141 }
2142
2143 else if(image->type == ImageTypeBitmap){
2144 *height = ((GpBitmap*)image)->height;
2145 *width = ((GpBitmap*)image)->width;
2146 }
2147 else{
2148 *height = ipicture_pixel_height(image->picture);
2149 *width = ipicture_pixel_width(image->picture);
2150 }
2151
2152 TRACE("returning (%f, %f)\n", *height, *width);
2153 return Ok;
2154 }
2155
2156 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2157 GpGraphics **graphics)
2158 {
2159 HDC hdc;
2160 GpStatus stat;
2161
2162 TRACE("%p %p\n", image, graphics);
2163
2164 if(!image || !graphics)
2165 return InvalidParameter;
2166
2167 if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2168 {
2169 hdc = ((GpBitmap*)image)->hdc;
2170
2171 if(!hdc){
2172 hdc = CreateCompatibleDC(0);
2173 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2174 ((GpBitmap*)image)->hdc = hdc;
2175 }
2176
2177 stat = GdipCreateFromHDC(hdc, graphics);
2178
2179 if (stat == Ok)
2180 (*graphics)->image = image;
2181 }
2182 else if (image->type == ImageTypeMetafile)
2183 stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2184 else
2185 stat = graphics_from_image(image, graphics);
2186
2187 return stat;
2188 }
2189
2190 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2191 {
2192 TRACE("%p %p\n", image, height);
2193
2194 if(!image || !height)
2195 return InvalidParameter;
2196
2197 if(image->type == ImageTypeMetafile){
2198 HDC hdc = GetDC(0);
2199 REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2200
2201 ReleaseDC(0, hdc);
2202
2203 *height = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2204 ((GpMetafile*)image)->bounds.Height);
2205 }
2206 else if(image->type == ImageTypeBitmap)
2207 *height = ((GpBitmap*)image)->height;
2208 else
2209 *height = ipicture_pixel_height(image->picture);
2210
2211 TRACE("returning %d\n", *height);
2212
2213 return Ok;
2214 }
2215
2216 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2217 {
2218 if(!image || !res)
2219 return InvalidParameter;
2220
2221 *res = image->xres;
2222
2223 TRACE("(%p) <-- %0.2f\n", image, *res);
2224
2225 return Ok;
2226 }
2227
2228 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2229 {
2230 TRACE("%p %p\n", image, size);
2231
2232 if(!image || !size)
2233 return InvalidParameter;
2234
2235 if (image->palette_count == 0)
2236 *size = sizeof(ColorPalette);
2237 else
2238 *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette_count;
2239
2240 TRACE("<-- %u\n", *size);
2241
2242 return Ok;
2243 }
2244
2245 /* FIXME: test this function for non-bitmap types */
2246 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2247 {
2248 TRACE("%p %p\n", image, format);
2249
2250 if(!image || !format)
2251 return InvalidParameter;
2252
2253 if(image->type != ImageTypeBitmap)
2254 *format = PixelFormat24bppRGB;
2255 else
2256 *format = ((GpBitmap*) image)->format;
2257
2258 return Ok;
2259 }
2260
2261 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2262 {
2263 TRACE("(%p, %p)\n", image, format);
2264
2265 if(!image || !format)
2266 return InvalidParameter;
2267
2268 memcpy(format, &image->format, sizeof(GUID));
2269
2270 return Ok;
2271 }
2272
2273 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2274 {
2275 TRACE("%p %p\n", image, type);
2276
2277 if(!image || !type)
2278 return InvalidParameter;
2279
2280 *type = image->type;
2281
2282 return Ok;
2283 }
2284
2285 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2286 {
2287 if(!image || !res)
2288 return InvalidParameter;
2289
2290 *res = image->yres;
2291
2292 TRACE("(%p) <-- %0.2f\n", image, *res);
2293
2294 return Ok;
2295 }
2296
2297 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2298 {
2299 TRACE("%p %p\n", image, width);
2300
2301 if(!image || !width)
2302 return InvalidParameter;
2303
2304 if(image->type == ImageTypeMetafile){
2305 HDC hdc = GetDC(0);
2306 REAL res = (REAL)GetDeviceCaps(hdc, LOGPIXELSX);
2307
2308 ReleaseDC(0, hdc);
2309
2310 *width = roundr(convert_unit(res, ((GpMetafile*)image)->unit) *
2311 ((GpMetafile*)image)->bounds.Width);
2312 }
2313 else if(image->type == ImageTypeBitmap)
2314 *width = ((GpBitmap*)image)->width;
2315 else
2316 *width = ipicture_pixel_width(image->picture);
2317
2318 TRACE("returning %d\n", *width);
2319
2320 return Ok;
2321 }
2322
2323 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
2324 MetafileHeader * header)
2325 {
2326 static int calls;
2327
2328 TRACE("(%p, %p)\n", metafile, header);
2329
2330 if(!metafile || !header)
2331 return InvalidParameter;
2332
2333 if(!(calls++))
2334 FIXME("not implemented\n");
2335
2336 memset(header, 0, sizeof(MetafileHeader));
2337
2338 return Ok;
2339 }
2340
2341 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf(HENHMETAFILE hEmf,
2342 MetafileHeader *header)
2343 {
2344 static int calls;
2345
2346 if(!hEmf || !header)
2347 return InvalidParameter;
2348
2349 if(!(calls++))
2350 FIXME("not implemented\n");
2351
2352 memset(header, 0, sizeof(MetafileHeader));
2353
2354 return Ok;
2355 }
2356
2357 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile(GDIPCONST WCHAR *filename,
2358 MetafileHeader *header)
2359 {
2360 static int calls;
2361
2362 TRACE("(%s,%p)\n", debugstr_w(filename), header);
2363
2364 if(!filename || !header)
2365 return InvalidParameter;
2366
2367 if(!(calls++))
2368 FIXME("not implemented\n");
2369
2370 memset(header, 0, sizeof(MetafileHeader));
2371
2372 return Ok;
2373 }
2374
2375 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream(IStream *stream,
2376 MetafileHeader *header)
2377 {
2378 static int calls;
2379
2380 TRACE("(%p,%p)\n", stream, header);
2381
2382 if(!stream || !header)
2383 return InvalidParameter;
2384
2385 if(!(calls++))
2386 FIXME("not implemented\n");
2387
2388 memset(header, 0, sizeof(MetafileHeader));
2389
2390 return Ok;
2391 }
2392
2393 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2394 UINT num, PropertyItem* items)
2395 {
2396 static int calls;
2397
2398 TRACE("(%p, %u, %u, %p)\n", image, size, num, items);
2399
2400 if(!(calls++))
2401 FIXME("not implemented\n");
2402
2403 return InvalidParameter;
2404 }
2405
2406 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2407 {
2408 TRACE("(%p, %p)\n", image, num);
2409
2410 if (!image || !num) return InvalidParameter;
2411
2412 *num = 0;
2413
2414 if (image->type == ImageTypeBitmap)
2415 {
2416 if (((GpBitmap *)image)->metadata_reader)
2417 IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2418 }
2419
2420 return Ok;
2421 }
2422
2423 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2424 {
2425 HRESULT hr;
2426 IWICMetadataReader *reader;
2427 IWICEnumMetadataItem *enumerator;
2428 UINT prop_count, i, items_returned;
2429
2430 TRACE("(%p, %u, %p)\n", image, num, list);
2431
2432 if (!image || !list) return InvalidParameter;
2433
2434 if (image->type != ImageTypeBitmap)
2435 {
2436 FIXME("Not implemented for type %d\n", image->type);
2437 return NotImplemented;
2438 }
2439
2440 reader = ((GpBitmap *)image)->metadata_reader;
2441 if (!reader)
2442 {
2443 if (num != 0) return InvalidParameter;
2444 return Ok;
2445 }
2446
2447 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2448 if (FAILED(hr)) return hresult_to_status(hr);
2449
2450 if (num != prop_count) return InvalidParameter;
2451
2452 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2453 if (FAILED(hr)) return hresult_to_status(hr);
2454
2455 IWICEnumMetadataItem_Reset(enumerator);
2456
2457 for (i = 0; i < num; i++)
2458 {
2459 PROPVARIANT id;
2460
2461 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2462 if (hr != S_OK) break;
2463
2464 if (id.vt != VT_UI2)
2465 {
2466 FIXME("not supported propvariant type for id: %u\n", id.vt);
2467 list[i] = 0;
2468 continue;
2469 }
2470 list[i] = id.u.uiVal;
2471 }
2472
2473 IWICEnumMetadataItem_Release(enumerator);
2474
2475 return hr == S_OK ? Ok : hresult_to_status(hr);
2476 }
2477
2478 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
2479 PropertyItem* buffer)
2480 {
2481 static int calls;
2482
2483 TRACE("(%p, %u, %u, %p)\n", image, id, size, buffer);
2484
2485 if(!(calls++))
2486 FIXME("not implemented\n");
2487
2488 return InvalidParameter;
2489 }
2490
2491 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
2492 UINT* size)
2493 {
2494 static int calls;
2495
2496 TRACE("%p %x %p\n", image, pid, size);
2497
2498 if(!size || !image)
2499 return InvalidParameter;
2500
2501 if(!(calls++))
2502 FIXME("not implemented\n");
2503
2504 return NotImplemented;
2505 }
2506
2507 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
2508 {
2509 static int calls;
2510
2511 TRACE("(%p,%p,%p)\n", image, size, num);
2512
2513 if(!(calls++))
2514 FIXME("not implemented\n");
2515
2516 return InvalidParameter;
2517 }
2518
2519 struct image_format_dimension
2520 {
2521 const GUID *format;
2522 const GUID *dimension;
2523 };
2524
2525 static const struct image_format_dimension image_format_dimensions[] =
2526 {
2527 {&ImageFormatGIF, &FrameDimensionTime},
2528 {&ImageFormatIcon, &FrameDimensionResolution},
2529 {NULL}
2530 };
2531
2532 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2533 GDIPCONST GUID* dimensionID, UINT* count)
2534 {
2535 TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2536
2537 if(!image || !count)
2538 return InvalidParameter;
2539
2540 if (!dimensionID ||
2541 IsEqualGUID(dimensionID, &image->format) ||
2542 IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2543 IsEqualGUID(dimensionID, &FrameDimensionTime))
2544 {
2545 *count = image->frame_count;
2546 return Ok;
2547 }
2548
2549 return InvalidParameter;
2550 }
2551
2552 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2553 UINT* count)
2554 {
2555 TRACE("(%p, %p)\n", image, count);
2556
2557 /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2558
2559 if(!image || !count)
2560 return InvalidParameter;
2561
2562 *count = 1;
2563
2564 return Ok;
2565 }
2566
2567 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2568 GUID* dimensionIDs, UINT count)
2569 {
2570 int i;
2571 const GUID *result=NULL;
2572
2573 TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2574
2575 if(!image || !dimensionIDs || count != 1)
2576 return InvalidParameter;
2577
2578 for (i=0; image_format_dimensions[i].format; i++)
2579 {
2580 if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2581 {
2582 result = image_format_dimensions[i].dimension;
2583 break;
2584 }
2585 }
2586
2587 if (!result)
2588 result = &FrameDimensionPage;
2589
2590 memcpy(dimensionIDs, result, sizeof(GUID));
2591
2592 return Ok;
2593 }
2594
2595 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2596 GpImage **image)
2597 {
2598 GpStatus stat;
2599 IStream *stream;
2600
2601 TRACE("(%s) %p\n", debugstr_w(filename), image);
2602
2603 if (!filename || !image)
2604 return InvalidParameter;
2605
2606 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2607
2608 if (stat != Ok)
2609 return stat;
2610
2611 stat = GdipLoadImageFromStream(stream, image);
2612
2613 IStream_Release(stream);
2614
2615 return stat;
2616 }
2617
2618 /* FIXME: no icm handling */
2619 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2620 {
2621 TRACE("(%s) %p\n", debugstr_w(filename), image);
2622
2623 return GdipLoadImageFromFile(filename, image);
2624 }
2625
2626 static const WICPixelFormatGUID * const wic_pixel_formats[] = {
2627 &GUID_WICPixelFormat16bppBGR555,
2628 &GUID_WICPixelFormat24bppBGR,
2629 &GUID_WICPixelFormat32bppBGR,
2630 &GUID_WICPixelFormat32bppBGRA,
2631 &GUID_WICPixelFormat32bppPBGRA,
2632 NULL
2633 };
2634
2635 static const PixelFormat wic_gdip_formats[] = {
2636 PixelFormat16bppRGB555,
2637 PixelFormat24bppRGB,
2638 PixelFormat32bppRGB,
2639 PixelFormat32bppARGB,
2640 PixelFormat32bppPARGB,
2641 };
2642
2643 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2644 {
2645 GpStatus status=Ok;
2646 GpBitmap *bitmap;
2647 HRESULT hr;
2648 IWICBitmapDecoder *decoder;
2649 IWICBitmapFrameDecode *frame;
2650 IWICBitmapSource *source=NULL;
2651 IWICMetadataBlockReader *block_reader;
2652 WICPixelFormatGUID wic_format;
2653 PixelFormat gdip_format=0;
2654 int i;
2655 UINT width, height, frame_count;
2656 BitmapData lockeddata;
2657 WICRect wrc;
2658 HRESULT initresult;
2659
2660 initresult = CoInitialize(NULL);
2661
2662 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2663 &IID_IWICBitmapDecoder, (void**)&decoder);
2664 if (FAILED(hr)) goto end;
2665
2666 hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
2667 if (SUCCEEDED(hr))
2668 {
2669 IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
2670 hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
2671 }
2672
2673 if (SUCCEEDED(hr)) /* got frame */
2674 {
2675 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
2676
2677 if (SUCCEEDED(hr))
2678 {
2679 IWICBitmapSource *bmp_source;
2680 IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICBitmapSource, (void **)&bmp_source);
2681
2682 for (i=0; wic_pixel_formats[i]; i++)
2683 {
2684 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
2685 {
2686 source = bmp_source;
2687 gdip_format = wic_gdip_formats[i];
2688 break;
2689 }
2690 }
2691 if (!source)
2692 {
2693 /* unknown format; fall back on 32bppARGB */
2694 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, bmp_source, &source);
2695 gdip_format = PixelFormat32bppARGB;
2696 IWICBitmapSource_Release(bmp_source);
2697 }
2698 }
2699
2700 if (SUCCEEDED(hr)) /* got source */
2701 {
2702 hr = IWICBitmapSource_GetSize(source, &width, &height);
2703
2704 if (SUCCEEDED(hr))
2705 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
2706 NULL, &bitmap);
2707
2708 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
2709 {
2710 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
2711 gdip_format, &lockeddata);
2712 if (status == Ok) /* locked bitmap */
2713 {
2714 wrc.X = 0;
2715 wrc.Width = width;
2716 wrc.Height = 1;
2717 for (i=0; i<height; i++)
2718 {
2719 wrc.Y = i;
2720 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
2721 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
2722 if (FAILED(hr)) break;
2723 }
2724
2725 GdipBitmapUnlockBits(bitmap, &lockeddata);
2726 }
2727
2728 if (SUCCEEDED(hr) && status == Ok)
2729 *image = (GpImage*)bitmap;
2730 else
2731 {
2732 *image = NULL;
2733 GdipDisposeImage((GpImage*)bitmap);
2734 }
2735
2736 if (SUCCEEDED(hr) && status == Ok)
2737 {
2738 double dpix, dpiy;
2739 hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
2740 if (SUCCEEDED(hr))
2741 {
2742 bitmap->image.xres = dpix;
2743 bitmap->image.yres = dpiy;
2744 }
2745 hr = S_OK;
2746 }
2747 }
2748
2749 IWICBitmapSource_Release(source);
2750 }
2751
2752 bitmap->metadata_reader = NULL;
2753 if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
2754 {
2755 UINT block_count = 0;
2756 if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
2757 IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
2758 IWICMetadataBlockReader_Release(block_reader);
2759 }
2760
2761 IWICBitmapFrameDecode_Release(frame);
2762 }
2763
2764 IWICBitmapDecoder_Release(decoder);
2765
2766 end:
2767 if (SUCCEEDED(initresult)) CoUninitialize();
2768
2769 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
2770
2771 if (status == Ok)
2772 {
2773 /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
2774 bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI|ImageFlagsColorSpaceRGB;
2775 bitmap->image.frame_count = frame_count;
2776 bitmap->image.current_frame = active_frame;
2777 bitmap->image.stream = stream;
2778 /* Pin the source stream */
2779 IStream_AddRef(stream);
2780 }
2781
2782 return status;
2783 }
2784
2785 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2786 {
2787 return decode_image_wic(stream, &CLSID_WICIcoDecoder, active_frame, image);
2788 }
2789
2790 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2791 {
2792 GpStatus status;
2793 GpBitmap* bitmap;
2794
2795 status = decode_image_wic(stream, &CLSID_WICBmpDecoder, active_frame, image);
2796
2797 bitmap = (GpBitmap*)*image;
2798
2799 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
2800 {
2801 /* WIC supports bmp files with alpha, but gdiplus does not */
2802 bitmap->format = PixelFormat32bppRGB;
2803 }
2804
2805 return status;
2806 }
2807
2808 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2809 {
2810 return decode_image_wic(stream, &CLSID_WICJpegDecoder, active_frame, image);
2811 }
2812
2813 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2814 {
2815 return decode_image_wic(stream, &CLSID_WICPngDecoder, active_frame, image);
2816 }
2817
2818 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2819 {
2820 return decode_image_wic(stream, &CLSID_WICGifDecoder, active_frame, image);
2821 }
2822
2823 static GpStatus decode_image_tiff(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2824 {
2825 return decode_image_wic(stream, &CLSID_WICTiffDecoder, active_frame, image);
2826 }
2827
2828 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2829 {
2830 IPicture *pic;
2831
2832 TRACE("%p %p\n", stream, image);
2833
2834 if(!stream || !image)
2835 return InvalidParameter;
2836
2837 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
2838 (LPVOID*) &pic) != S_OK){
2839 TRACE("Could not load picture\n");
2840 return GenericError;
2841 }
2842
2843 /* FIXME: missing initialization code */
2844 *image = GdipAlloc(sizeof(GpMetafile));
2845 if(!*image) return OutOfMemory;
2846 (*image)->type = ImageTypeMetafile;
2847 (*image)->stream = NULL;
2848 (*image)->picture = pic;
2849 (*image)->flags = ImageFlagsNone;
2850 (*image)->frame_count = 1;
2851 (*image)->current_frame = 0;
2852 (*image)->palette_flags = 0;
2853 (*image)->palette_count = 0;
2854 (*image)->palette_size = 0;
2855 (*image)->palette_entries = NULL;
2856
2857 TRACE("<-- %p\n", *image);
2858
2859 return Ok;
2860 }
2861
2862 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
2863 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
2864
2865 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, UINT active_frame, GpImage **image);
2866
2867 typedef struct image_codec {
2868 ImageCodecInfo info;
2869 encode_image_func encode_func;
2870 decode_image_func decode_func;
2871 } image_codec;
2872
2873 typedef enum {
2874 BMP,
2875 JPEG,
2876 GIF,
2877 TIFF,
2878 EMF,
2879 WMF,
2880 PNG,
2881 ICO,
2882 NUM_CODECS
2883 } ImageFormat;
2884
2885 static const struct image_codec codecs[NUM_CODECS];
2886
2887 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
2888 {
2889 BYTE signature[8];
2890 const BYTE *pattern, *mask;
2891 LARGE_INTEGER seek;
2892 HRESULT hr;
2893 UINT bytesread;
2894 int i, j, sig;
2895
2896 /* seek to the start of the stream */
2897 seek.QuadPart = 0;
2898 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
2899 if (FAILED(hr)) return hresult_to_status(hr);
2900
2901 /* read the first 8 bytes */
2902 /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
2903 hr = IStream_Read(stream, signature, 8, &bytesread);
2904 if (FAILED(hr)) return hresult_to_status(hr);
2905 if (hr == S_FALSE || bytesread == 0) return GenericError;
2906
2907 for (i = 0; i < NUM_CODECS; i++) {
2908 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
2909 bytesread >= codecs[i].info.SigSize)
2910 {
2911 for (sig=0; sig<codecs[i].info.SigCount; sig++)
2912 {
2913 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
2914 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
2915 for (j=0; j<codecs[i].info.SigSize; j++)
2916 if ((signature[j] & mask[j]) != pattern[j])
2917 break;
2918 if (j == codecs[i].info.SigSize)
2919 {
2920 *result = &codecs[i];
2921 return Ok;
2922 }
2923 }
2924 }
2925 }
2926
2927 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
2928 signature[0],signature[1],signature[2],signature[3],
2929 signature[4],signature[5],signature[6],signature[7]);
2930
2931 return GenericError;
2932 }
2933
2934 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
2935 UINT frame)
2936 {
2937 GpStatus stat;
2938 LARGE_INTEGER seek;
2939 HRESULT hr;
2940 const struct image_codec *codec = NULL;
2941 IStream *stream;
2942 GpImage *new_image;
2943
2944 TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
2945
2946 if (!image || !dimensionID)
2947 return InvalidParameter;
2948
2949 if (frame >= image->frame_count)
2950 return InvalidParameter;
2951
2952 if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
2953 {
2954 WARN("invalid image type %d\n", image->type);
2955 return InvalidParameter;
2956 }
2957
2958 if (image->current_frame == frame)
2959 return Ok;
2960
2961 if (!image->stream)
2962 {
2963 TRACE("image doesn't have an associated stream\n");
2964 return Ok;
2965 }
2966
2967 hr = IStream_Clone(image->stream, &stream);
2968 if (FAILED(hr))
2969 {
2970 STATSTG statstg;
2971
2972 hr = IStream_Stat(image->stream, &statstg, STATFLAG_NOOPEN);
2973 if (FAILED(hr)) return hresult_to_status(hr);
2974
2975 stat = GdipCreateStreamOnFile(statstg.pwcsName, GENERIC_READ, &stream);
2976 if (stat != Ok) return stat;
2977 }
2978
2979 /* choose an appropriate image decoder */
2980 stat = get_decoder_info(stream, &codec);
2981 if (stat != Ok)
2982 {
2983 IStream_Release(stream);
2984 return stat;
2985 }
2986
2987 /* seek to the start of the stream */
2988 seek.QuadPart = 0;
2989 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
2990 if (FAILED(hr))
2991 {
2992 IStream_Release(stream);
2993 return hresult_to_status(hr);
2994 }
2995
2996 /* call on the image decoder to do the real work */
2997 stat = codec->decode_func(stream, &codec->info.Clsid, frame, &new_image);
2998
2999 if (stat == Ok)
3000 {
3001 memcpy(&new_image->format, &codec->info.FormatID, sizeof(GUID));
3002 free_image_data(image);
3003 if (image->type == ImageTypeBitmap)
3004 *(GpBitmap *)image = *(GpBitmap *)new_image;
3005 else if (image->type == ImageTypeMetafile)
3006 *(GpMetafile *)image = *(GpMetafile *)new_image;
3007 new_image->type = ~0;
3008 GdipFree(new_image);
3009 return Ok;
3010 }
3011
3012 IStream_Release(stream);
3013 return stat;
3014 }
3015
3016 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
3017 {
3018 GpStatus stat;
3019 LARGE_INTEGER seek;
3020 HRESULT hr;
3021 const struct image_codec *codec=NULL;
3022
3023 /* choose an appropriate image decoder */
3024 stat = get_decoder_info(stream, &codec);
3025 if (stat != Ok) return stat;
3026
3027 /* seek to the start of the stream */
3028 seek.QuadPart = 0;
3029 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3030 if (FAILED(hr)) return hresult_to_status(hr);
3031
3032 /* call on the image decoder to do the real work */
3033 stat = codec->decode_func(stream, &codec->info.Clsid, 0, image);
3034
3035 /* take note of the original data format */
3036 if (stat == Ok)
3037 {
3038 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
3039 return Ok;
3040 }
3041
3042 return stat;
3043 }
3044
3045 /* FIXME: no ICM */
3046 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
3047 {
3048 TRACE("%p %p\n", stream, image);
3049
3050 return GdipLoadImageFromStream(stream, image);
3051 }
3052
3053 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
3054 {
3055 static int calls;
3056
3057 TRACE("(%p,%u)\n", image, propId);
3058
3059 if(!image)
3060 return InvalidParameter;
3061
3062 if(!(calls++))
3063 FIXME("not implemented\n");
3064
3065 return NotImplemented;
3066 }
3067
3068 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
3069 {
3070 static int calls;
3071
3072 TRACE("(%p,%p)\n", image, item);
3073
3074 if(!(calls++))
3075 FIXME("not implemented\n");
3076
3077 return NotImplemented;
3078 }
3079
3080 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
3081 GDIPCONST CLSID *clsidEncoder,
3082 GDIPCONST EncoderParameters *encoderParams)
3083 {
3084 GpStatus stat;
3085 IStream *stream;
3086
3087 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
3088
3089 if (!image || !filename|| !clsidEncoder)
3090 return InvalidParameter;
3091
3092 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
3093 if (stat != Ok)
3094 return GenericError;
3095
3096 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
3097
3098 IStream_Release(stream);
3099 return stat;
3100 }
3101
3102 /*************************************************************************
3103 * Encoding functions -
3104 * These functions encode an image in different image file formats.
3105 */
3106 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
3107 #define BITMAP_FORMAT_JPEG 0xd8ff
3108 #define BITMAP_FORMAT_GIF 0x4947
3109 #define BITMAP_FORMAT_PNG 0x5089
3110 #define BITMAP_FORMAT_APM 0xcdd7
3111
3112 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
3113 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3114 {
3115 GpStatus stat;
3116 GpBitmap *bitmap;
3117 IWICBitmapEncoder *encoder;
3118 IWICBitmapFrameEncode *frameencode;
3119 IPropertyBag2 *encoderoptions;
3120 HRESULT hr;
3121 UINT width, height;
3122 PixelFormat gdipformat=0;
3123 WICPixelFormatGUID wicformat;
3124 GpRect rc;
3125 BitmapData lockeddata;
3126 HRESULT initresult;
3127 UINT i;
3128
3129 if (image->type != ImageTypeBitmap)
3130 return GenericError;
3131
3132 bitmap = (GpBitmap*)image;
3133
3134 GdipGetImageWidth(image, &width);
3135 GdipGetImageHeight(image, &height);
3136
3137 rc.X = 0;
3138 rc.Y = 0;
3139 rc.Width = width;
3140 rc.Height = height;
3141
3142 initresult = CoInitialize(NULL);
3143
3144 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
3145 &IID_IWICBitmapEncoder, (void**)&encoder);
3146 if (FAILED(hr))
3147 {
3148 if (SUCCEEDED(initresult)) CoUninitialize();
3149 return hresult_to_status(hr);
3150 }
3151
3152 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
3153
3154 if (SUCCEEDED(hr))
3155 {
3156 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
3157 }
3158
3159 if (SUCCEEDED(hr)) /* created frame */
3160 {
3161 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
3162
3163 if (SUCCEEDED(hr))
3164 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
3165
3166 if (SUCCEEDED(hr))
3167 /* FIXME: use the resolution from the image */
3168 hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
3169
3170 if (SUCCEEDED(hr))
3171 {
3172 for (i=0; wic_pixel_formats[i]; i++)
3173 {
3174 if (wic_gdip_formats[i] == bitmap->format)
3175 break;
3176 }
3177 if (wic_pixel_formats[i])
3178 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
3179 else
3180 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
3181
3182 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
3183
3184 for (i=0; wic_pixel_formats[i]; i++)
3185 {
3186 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
3187 break;
3188 }
3189 if (wic_pixel_formats[i])
3190 gdipformat = wic_gdip_formats[i];
3191 else
3192 {
3193 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
3194 hr = E_FAIL;
3195 }
3196 }
3197
3198 if (SUCCEEDED(hr))
3199 {
3200 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
3201 &lockeddata);
3202
3203 if (stat == Ok)
3204 {
3205 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
3206 BYTE *row;
3207
3208 /* write one row at a time in case stride is negative */
3209 row = lockeddata.Scan0;
3210 for (i=0; i<lockeddata.Height; i++)
3211 {
3212 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
3213 if (FAILED(hr)) break;
3214 row += lockeddata.Stride;
3215 }
3216
3217 GdipBitmapUnlockBits(bitmap, &lockeddata);
3218 }
3219 else
3220 hr = E_FAIL;
3221 }
3222
3223 if (SUCCEEDED(hr))
3224 hr = IWICBitmapFrameEncode_Commit(frameencode);
3225
3226 IWICBitmapFrameEncode_Release(frameencode);
3227 IPropertyBag2_Release(encoderoptions);
3228 }
3229
3230 if (SUCCEEDED(hr))
3231 hr = IWICBitmapEncoder_Commit(encoder);
3232
3233 IWICBitmapEncoder_Release(encoder);
3234
3235 if (SUCCEEDED(initresult)) CoUninitialize();
3236
3237 return hresult_to_status(hr);
3238 }
3239
3240 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
3241 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3242 {
3243 return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
3244 }
3245
3246 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
3247 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3248 {
3249 return encode_image_WIC(image, stream, &CLSID_WICTiffEncoder, params);
3250 }
3251
3252 static GpStatus encode_image_png(GpImage *image, IStream* stream,
3253 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3254 {
3255 return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
3256 }
3257
3258 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
3259 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3260 {
3261 return encode_image_WIC(image, stream, &CLSID_WICJpegEncoder, params);
3262 }
3263
3264 /*****************************************************************************
3265 * GdipSaveImageToStream [GDIPLUS.@]
3266 */
3267 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
3268 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3269 {
3270 GpStatus stat;
3271 encode_image_func encode_image;
3272 int i;
3273
3274 TRACE("%p %p %p %p\n", image, stream, clsid, params);
3275
3276 if(!image || !stream)
3277 return InvalidParameter;
3278
3279 /* select correct encoder */
3280 encode_image = NULL;
3281 for (i = 0; i < NUM_CODECS; i++) {
3282 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
3283 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
3284 encode_image = codecs[i].encode_func;
3285 }
3286 if (encode_image == NULL)
3287 return UnknownImageFormat;
3288
3289 stat = encode_image(image, stream, clsid, params);
3290
3291 return stat;
3292 }
3293
3294 /*****************************************************************************
3295 * GdipGetImagePalette [GDIPLUS.@]
3296 */
3297 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
3298 {
3299 TRACE("(%p,%p,%i)\n", image, palette, size);
3300
3301 if (!image || !palette)
3302 return InvalidParameter;
3303
3304 if (size < (sizeof(UINT)*2+sizeof(ARGB)*image->palette_count))
3305 {
3306 TRACE("<-- InsufficientBuffer\n");
3307 return InsufficientBuffer;
3308 }
3309
3310 palette->Flags = image->palette_flags;
3311 palette->Count = image->palette_count;
3312 memcpy(palette->Entries, image->palette_entries, sizeof(ARGB)*image->palette_count);
3313
3314 return Ok;
3315 }
3316
3317 /*****************************************************************************
3318 * GdipSetImagePalette [GDIPLUS.@]
3319 */
3320 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
3321 GDIPCONST ColorPalette *palette)
3322 {
3323 TRACE("(%p,%p)\n", image, palette);
3324
3325 if(!image || !palette || palette->Count > 256)
3326 return InvalidParameter;
3327
3328 if (palette->Count > image->palette_size)
3329 {
3330 ARGB *new_palette;
3331
3332 new_palette = GdipAlloc(sizeof(ARGB) * palette->Count);
3333 if (!new_palette) return OutOfMemory;
3334
3335 GdipFree(image->palette_entries);
3336 image->palette_entries = new_palette;
3337 image->palette_size = palette->Count;
3338 }
3339
3340 image->palette_flags = palette->Flags;
3341 image->palette_count = palette->Count;
3342 memcpy(image->palette_entries, palette->Entries, sizeof(ARGB)*palette->Count);
3343
3344 return Ok;
3345 }
3346
3347 /*************************************************************************
3348 * Encoders -
3349 * Structures that represent which formats we support for encoding.
3350 */
3351
3352 /* ImageCodecInfo creation routines taken from libgdiplus */
3353 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
3354 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
3355 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
3356 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
3357 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
3358 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
3359
3360 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
3361 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
3362 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
3363 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
3364 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
3365 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
3366
3367 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
3368 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
3369 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
3370 static const WCHAR gif_format[] = {'G','I','F',0};
3371 static const BYTE gif_sig_pattern[4] = "GIF8";
3372 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3373
3374 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
3375 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
3376 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
3377 static const WCHAR tiff_format[] = {'T','I','F','F',0};
3378 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
3379 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3380
3381 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
3382 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
3383 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
3384 static const WCHAR emf_format[] = {'E','M','F',0};
3385 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
3386 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3387
3388 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
3389 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
3390 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
3391 static const WCHAR wmf_format[] = {'W','M','F',0};
3392 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
3393 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
3394
3395 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
3396 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
3397 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
3398 static const WCHAR png_format[] = {'P','N','G',0};
3399 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
3400 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3401
3402 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
3403 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
3404 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
3405 static const WCHAR ico_format[] = {'I','C','O',0};
3406 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
3407 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3408
3409 static const struct image_codec codecs[NUM_CODECS] = {
3410 {
3411 { /* BMP */
3412 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3413 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3414 /* CodecName */ bmp_codecname,
3415 /* DllName */ NULL,
3416 /* FormatDescription */ bmp_format,
3417 /* FilenameExtension */ bmp_extension,
3418 /* MimeType */ bmp_mimetype,
3419 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3420 /* Version */ 1,
3421 /* SigCount */ 1,
3422 /* SigSize */ 2,
3423 /* SigPattern */ bmp_sig_pattern,
3424 /* SigMask */ bmp_sig_mask,
3425 },
3426 encode_image_BMP,
3427 decode_image_bmp
3428 },
3429 {
3430 { /* JPEG */
3431 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3432 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3433 /* CodecName */ jpeg_codecname,
3434 /* DllName */ NULL,
3435 /* FormatDescription */ jpeg_format,
3436 /* FilenameExtension */ jpeg_extension,
3437 /* MimeType */ jpeg_mimetype,
3438 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3439 /* Version */ 1,
3440 /* SigCount */ 1,
3441 /* SigSize */ 2,
3442 /* SigPattern */ jpeg_sig_pattern,
3443 /* SigMask */ jpeg_sig_mask,
3444 },
3445 encode_image_jpeg,
3446 decode_image_jpeg
3447 },
3448 {
3449 { /* GIF */
3450 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3451 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3452 /* CodecName */ gif_codecname,
3453 /* DllName */ NULL,
3454 /* FormatDescription */ gif_format,
3455 /* FilenameExtension */ gif_extension,
3456 /* MimeType */ gif_mimetype,
3457 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3458 /* Version */ 1,
3459 /* SigCount */ 1,
3460 /* SigSize */ 4,
3461 /* SigPattern */ gif_sig_pattern,
3462 /* SigMask */ gif_sig_mask,
3463 },
3464 NULL,
3465 decode_image_gif
3466 },
3467 {
3468 { /* TIFF */
3469 /* Clsid */ { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3470 /* FormatID */ { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3471 /* CodecName */ tiff_codecname,
3472 /* DllName */ NULL,
3473 /* FormatDescription */ tiff_format,
3474 /* FilenameExtension */ tiff_extension,
3475 /* MimeType */ tiff_mimetype,
3476 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3477 /* Version */ 1,
3478 /* SigCount */ 2,
3479 /* SigSize */ 4,
3480 /* SigPattern */ tiff_sig_pattern,
3481 /* SigMask */ tiff_sig_mask,
3482 },
3483 encode_image_tiff,
3484 decode_image_tiff
3485 },
3486 {
3487 { /* EMF */
3488 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3489 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3490 /* CodecName */ emf_codecname,
3491 /* DllName */ NULL,
3492 /* FormatDescription */ emf_format,
3493 /* FilenameExtension */ emf_extension,
3494 /* MimeType */ emf_mimetype,
3495 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3496 /* Version */ 1,
3497 /* SigCount */ 1,
3498 /* SigSize */ 4,
3499 /* SigPattern */ emf_sig_pattern,
3500 /* SigMask */ emf_sig_mask,
3501 },
3502 NULL,
3503 decode_image_olepicture_metafile
3504 },
3505 {
3506 { /* WMF */
3507 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3508 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3509 /* CodecName */ wmf_codecname,
3510 /* DllName */ NULL,
3511 /* FormatDescription */ wmf_format,
3512 /* FilenameExtension */ wmf_extension,
3513 /* MimeType */ wmf_mimetype,
3514 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3515 /* Version */ 1,
3516 /* SigCount */ 1,
3517 /* SigSize */ 2,
3518 /* SigPattern */ wmf_sig_pattern,
3519 /* SigMask */ wmf_sig_mask,
3520 },
3521 NULL,
3522 decode_image_olepicture_metafile
3523 },
3524 {
3525 { /* PNG */
3526 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3527 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3528 /* CodecName */ png_codecname,
3529 /* DllName */ NULL,
3530 /* FormatDescription */ png_format,
3531 /* FilenameExtension */ png_extension,
3532 /* MimeType */ png_mimetype,
3533 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3534 /* Version */ 1,
3535 /* SigCount */ 1,
3536 /* SigSize */ 8,
3537 /* SigPattern */ png_sig_pattern,
3538 /* SigMask */ png_sig_mask,
3539 },
3540 encode_image_png,
3541 decode_image_png
3542 },
3543 {
3544 { /* ICO */
3545 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3546 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3547 /* CodecName */ ico_codecname,
3548 /* DllName */ NULL,
3549 /* FormatDescription */ ico_format,
3550 /* FilenameExtension */ ico_extension,
3551 /* MimeType */ ico_mimetype,
3552 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3553 /* Version */ 1,
3554 /* SigCount */ 1,
3555 /* SigSize */ 4,
3556 /* SigPattern */ ico_sig_pattern,
3557 /* SigMask */ ico_sig_mask,
3558 },
3559 NULL,
3560 decode_image_icon
3561 },
3562 };
3563
3564 /*****************************************************************************
3565 * GdipGetImageDecodersSize [GDIPLUS.@]
3566 */
3567 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
3568 {
3569 int decoder_count=0;
3570 int i;
3571 TRACE("%p %p\n", numDecoders, size);
3572
3573 if (!numDecoders || !size)
3574 return InvalidParameter;
3575
3576 for (i=0; i<NUM_CODECS; i++)
3577 {
3578 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3579 decoder_count++;
3580 }
3581
3582 *numDecoders = decoder_count;
3583 *size = decoder_count * sizeof(ImageCodecInfo);
3584
3585 return Ok;
3586 }
3587
3588 /*****************************************************************************
3589 * GdipGetImageDecoders [GDIPLUS.@]
3590 */
3591 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
3592 {
3593 int i, decoder_count=0;
3594 TRACE("%u %u %p\n", numDecoders, size, decoders);
3595
3596 if (!decoders ||
3597 size != numDecoders * sizeof(ImageCodecInfo))
3598 return GenericError;
3599
3600 for (i=0; i<NUM_CODECS; i++)
3601 {
3602 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3603 {
3604 if (decoder_count == numDecoders) return GenericError;
3605 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3606 decoder_count++;
3607 }
3608 }
3609
3610 if (decoder_count < numDecoders) return GenericError;
3611
3612 return Ok;
3613 }
3614
3615 /*****************************************************************************
3616 * GdipGetImageEncodersSize [GDIPLUS.@]
3617 */
3618 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
3619 {
3620 int encoder_count=0;
3621 int i;
3622 TRACE("%p %p\n", numEncoders, size);
3623
3624 if (!numEncoders || !size)
3625 return InvalidParameter;
3626
3627 for (i=0; i<NUM_CODECS; i++)
3628 {
3629 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3630 encoder_count++;
3631 }
3632
3633 *numEncoders = encoder_count;
3634 *size = encoder_count * sizeof(ImageCodecInfo);
3635
3636 return Ok;
3637 }
3638
3639 /*****************************************************************************
3640 * GdipGetImageEncoders [GDIPLUS.@]
3641 */
3642 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
3643 {
3644 int i, encoder_count=0;
3645 TRACE("%u %u %p\n", numEncoders, size, encoders);
3646
3647 if (!encoders ||
3648 size != numEncoders * sizeof(ImageCodecInfo))
3649 return GenericError;
3650
3651 for (i=0; i<NUM_CODECS; i++)
3652 {
3653 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3654 {
3655 if (encoder_count == numEncoders) return GenericError;
3656 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3657 encoder_count++;
3658 }
3659 }
3660
3661 if (encoder_count < numEncoders) return GenericError;
3662
3663 return Ok;
3664 }
3665
3666 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
3667 GDIPCONST CLSID* clsidEncoder, UINT *size)
3668 {
3669 static int calls;
3670
3671 TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
3672
3673 if(!(calls++))
3674 FIXME("not implemented\n");
3675
3676 *size = 0;
3677
3678 return NotImplemented;
3679 }
3680
3681 static PixelFormat get_16bpp_format(HBITMAP hbm)
3682 {
3683 BITMAPV4HEADER bmh;
3684 HDC hdc;
3685 PixelFormat result;
3686
3687 hdc = CreateCompatibleDC(NULL);
3688
3689 memset(&bmh, 0, sizeof(bmh));
3690 bmh.bV4Size = sizeof(bmh);
3691 bmh.bV4Width = 1;
3692 bmh.bV4Height = 1;
3693 bmh.bV4V4Compression = BI_BITFIELDS;
3694 bmh.bV4BitCount = 16;
3695
3696 GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
3697
3698 if (bmh.bV4RedMask == 0x7c00 &&
3699 bmh.bV4GreenMask == 0x3e0 &&
3700 bmh.bV4BlueMask == 0x1f)
3701 {
3702 result = PixelFormat16bppRGB555;
3703 }
3704 else if (bmh.bV4RedMask == 0xf800 &&
3705 bmh.bV4GreenMask == 0x7e0 &&
3706 bmh.bV4BlueMask == 0x1f)
3707 {
3708 result = PixelFormat16bppRGB565;
3709 }
3710 else
3711 {
3712 FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
3713 bmh.bV4GreenMask, bmh.bV4BlueMask);
3714 result = PixelFormatUndefined;
3715 }
3716
3717 DeleteDC(hdc);
3718
3719 return result;
3720 }
3721
3722 /*****************************************************************************
3723 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
3724 */
3725 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
3726 {
3727 BITMAP bm;
3728 GpStatus retval;
3729 PixelFormat format;
3730 BitmapData lockeddata;
3731 INT y;
3732
3733 TRACE("%p %p %p\n", hbm, hpal, bitmap);
3734
3735 if(!hbm || !bitmap)
3736 return InvalidParameter;
3737
3738 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
3739 return InvalidParameter;
3740
3741 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
3742 switch(bm.bmBitsPixel) {
3743 case 1:
3744 format = PixelFormat1bppIndexed;
3745 break;
3746 case 4:
3747 format = PixelFormat4bppIndexed;
3748 break;
3749 case 8:
3750 format = PixelFormat8bppIndexed;
3751 break;
3752 case 16:
3753 format = get_16bpp_format(hbm);
3754 if (format == PixelFormatUndefined)
3755 return InvalidParameter;
3756 break;
3757 case 24:
3758 format = PixelFormat24bppRGB;
3759 break;
3760 case 32:
3761 format = PixelFormat32bppRGB;
3762 break;
3763 case 48:
3764 format = PixelFormat48bppRGB;
3765 break;
3766 default:
3767 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
3768 return InvalidParameter;
3769 }
3770
3771 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
3772 format, NULL, bitmap);
3773
3774 if (retval == Ok)
3775 {
3776 retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
3777 format, &lockeddata);
3778 if (retval == Ok)
3779 {
3780 if (bm.bmBits)
3781 {
3782 for (y=0; y<bm.bmHeight; y++)
3783 {
3784 memcpy((BYTE*)lockeddata.Scan0+lockeddata.Stride*y,
3785 (BYTE*)bm.bmBits+bm.bmWidthBytes*(bm.bmHeight-1-y),
3786 bm.bmWidthBytes);
3787 }
3788 }
3789 else
3790 {
3791 HDC hdc;
3792 HBITMAP oldhbm;
3793 BITMAPINFO *pbmi;
3794 INT src_height, dst_stride;
3795 BYTE *dst_bits;
3796
3797 hdc = CreateCompatibleDC(NULL);
3798 oldhbm = SelectObject(hdc, hbm);
3799
3800 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
3801
3802 if (pbmi)
3803 {
3804 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
3805 pbmi->bmiHeader.biBitCount = 0;
3806
3807 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
3808
3809 src_height = abs(pbmi->bmiHeader.biHeight);
3810
3811 if (pbmi->bmiHeader.biHeight > 0)
3812 {
3813 dst_bits = (BYTE*)lockeddata.Scan0+lockeddata.Stride*(src_height-1);
3814 dst_stride = -lockeddata.Stride;
3815 }
3816 else
3817 {
3818 dst_bits = lockeddata.Scan0;
3819 dst_stride = lockeddata.Stride;
3820 }
3821
3822 for (y=0; y<src_height; y++)
3823 {
3824 GetDIBits(hdc, hbm, y, 1, dst_bits+dst_stride*y,
3825 pbmi, DIB_RGB_COLORS);
3826 }
3827
3828 GdipFree(pbmi);
3829 }
3830 else
3831 retval = OutOfMemory;
3832
3833 SelectObject(hdc, oldhbm);
3834 DeleteDC(hdc);
3835 }
3836
3837 GdipBitmapUnlockBits(*bitmap, &lockeddata);
3838 }
3839
3840 if (retval == Ok && hpal)
3841 {
3842 WORD num_palette_entries;
3843 PALETTEENTRY *palette_entries=NULL;
3844 ColorPalette *palette=NULL;
3845 int i;
3846
3847 if (!GetObjectW(hpal, sizeof(num_palette_entries), &num_palette_entries))
3848 retval = GenericError;
3849
3850 if (retval == Ok)
3851 {
3852 palette_entries = GdipAlloc(sizeof(PALETTEENTRY) * num_palette_entries);
3853 palette = GdipAlloc(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
3854
3855 if (!palette_entries || !palette)
3856 retval = OutOfMemory;
3857 }
3858
3859 if (retval == Ok)
3860 {
3861 if (!GetPaletteEntries(hpal, 0, num_palette_entries, palette_entries))
3862 retval = GenericError;
3863 }
3864
3865 if (retval == Ok)
3866 {
3867 palette->Flags = 0;
3868 palette->Count = num_palette_entries;
3869
3870 for (i=0; i<num_palette_entries; i++)
3871 {
3872 PALETTEENTRY * entry = &palette_entries[i];
3873 palette->Entries[i] = 0xff000000 | entry->peRed << 16 |
3874 entry->peGreen << 8 | entry->peBlue;
3875 }
3876
3877 retval = GdipSetImagePalette((GpImage*)*bitmap, palette);
3878 }
3879
3880 GdipFree(palette_entries);
3881 GdipFree(palette);
3882 }
3883
3884 if (retval != Ok)
3885 {
3886 GdipDisposeImage((GpImage*)*bitmap);
3887 *bitmap = NULL;
3888 }
3889 }
3890
3891 return retval;
3892 }
3893
3894 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
3895 {
3896 FIXME("(%p): stub\n", effect);
3897 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
3898 * in Windows's gdiplus */
3899 return NotImplemented;
3900 }
3901
3902 /*****************************************************************************
3903 * GdipSetEffectParameters [GDIPLUS.@]
3904 */
3905 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
3906 const VOID *params, const UINT size)
3907 {
3908 static int calls;
3909
3910 TRACE("(%p,%p,%u)\n", effect, params, size);
3911
3912 if(!(calls++))
3913 FIXME("not implemented\n");
3914
3915 return NotImplemented;
3916 }
3917
3918 /*****************************************************************************
3919 * GdipGetImageFlags [GDIPLUS.@]
3920 */
3921 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
3922 {
3923 TRACE("%p %p\n", image, flags);
3924
3925 if(!image || !flags)
3926 return InvalidParameter;
3927
3928 *flags = image->flags;
3929
3930 return Ok;
3931 }
3932
3933 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
3934 {
3935 TRACE("(%d, %p)\n", control, param);
3936
3937 switch(control){
3938 case TestControlForceBilinear:
3939 if(param)
3940 FIXME("TestControlForceBilinear not handled\n");
3941 break;
3942 case TestControlNoICM:
3943 if(param)
3944 FIXME("TestControlNoICM not handled\n");
3945 break;
3946 case TestControlGetBuildNumber:
3947 *((DWORD*)param) = 3102;
3948 break;
3949 }
3950
3951 return Ok;
3952 }
3953
3954 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
3955 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
3956 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
3957 GpMetafile **metafile)
3958 {
3959 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
3960 frameUnit, debugstr_w(desc), metafile);
3961
3962 return NotImplemented;
3963 }
3964
3965 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
3966 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
3967 GDIPCONST WCHAR *desc, GpMetafile **metafile)
3968 {
3969 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
3970 frameUnit, debugstr_w(desc), metafile);
3971
3972 return NotImplemented;
3973 }
3974
3975 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
3976 {
3977 TRACE("%p\n", image);
3978
3979 return Ok;
3980 }
3981
3982 /*****************************************************************************
3983 * GdipGetImageThumbnail [GDIPLUS.@]
3984 */
3985 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
3986 GpImage **ret_image, GetThumbnailImageAbort cb,
3987 VOID * cb_data)
3988 {
3989 GpStatus stat;
3990 GpGraphics *graphics;
3991 UINT srcwidth, srcheight;
3992
3993 TRACE("(%p %u %u %p %p %p)\n",
3994 image, width, height, ret_image, cb, cb_data);
3995
3996 if (!image || !ret_image)
3997 return InvalidParameter;
3998
3999 if (!width) width = 120;
4000 if (!height) height = 120;
4001
4002 GdipGetImageWidth(image, &srcwidth);
4003 GdipGetImageHeight(image, &srcheight);
4004
4005 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB,
4006 NULL, (GpBitmap**)ret_image);
4007
4008 if (stat == Ok)
4009 {
4010 stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
4011
4012 if (stat == Ok)
4013 {
4014 stat = GdipDrawImageRectRectI(graphics, image,
4015 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
4016 NULL, NULL, NULL);
4017
4018 GdipDeleteGraphics(graphics);
4019 }
4020
4021 if (stat != Ok)
4022 {
4023 GdipDisposeImage(*ret_image);
4024 *ret_image = NULL;
4025 }
4026 }
4027
4028 return stat;
4029 }
4030
4031 /*****************************************************************************
4032 * GdipImageRotateFlip [GDIPLUS.@]
4033 */
4034 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
4035 {
4036 GpBitmap *new_bitmap;
4037 GpBitmap *bitmap;
4038 int bpp, bytesperpixel;
4039 int rotate_90, flip_x, flip_y;
4040 int src_x_offset, src_y_offset;
4041 LPBYTE src_origin;
4042 UINT x, y, width, height;
4043 BitmapData src_lock, dst_lock;
4044 GpStatus stat;
4045
4046 TRACE("(%p, %u)\n", image, type);
4047
4048 if (!image)
4049 return InvalidParameter;
4050
4051 rotate_90 = type&1;
4052 flip_x = (type&6) == 2 || (type&6) == 4;
4053 flip_y = (type&3) == 1 || (type&3) == 2;
4054
4055 if (image->type != ImageTypeBitmap)
4056 {
4057 FIXME("Not implemented for type %i\n", image->type);
4058 return NotImplemented;
4059 }
4060
4061 bitmap = (GpBitmap*)image;
4062 bpp = PIXELFORMATBPP(bitmap->format);
4063
4064 if (bpp < 8)
4065 {
4066 FIXME("Not implemented for %i bit images\n", bpp);
4067 return NotImplemented;
4068 }
4069
4070 if (rotate_90)
4071 {
4072 width = bitmap->height;
4073 height = bitmap->width;
4074 }
4075 else
4076 {
4077 width = bitmap->width;
4078 height = bitmap->height;
4079 }
4080
4081 bytesperpixel = bpp/8;
4082
4083 stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
4084
4085 if (stat != Ok)
4086 return stat;
4087
4088 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
4089
4090 if (stat == Ok)
4091 {
4092 stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
4093
4094 if (stat == Ok)
4095 {
4096 LPBYTE src_row, src_pixel;
4097 LPBYTE dst_row, dst_pixel;
4098
4099 src_origin = src_lock.Scan0;
4100 if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
4101 if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
4102
4103 if (rotate_90)
4104 {
4105 if (flip_y) src_x_offset = -src_lock.Stride;
4106 else src_x_offset = src_lock.Stride;
4107 if (flip_x) src_y_offset = -bytesperpixel;
4108 else src_y_offset = bytesperpixel;
4109 }
4110 else
4111 {
4112 if (flip_x) src_x_offset = -bytesperpixel;
4113 else src_x_offset = bytesperpixel;
4114 if (flip_y) src_y_offset = -src_lock.Stride;
4115 else src_y_offset = src_lock.Stride;
4116 }
4117
4118 src_row = src_origin;
4119 dst_row = dst_lock.Scan0;
4120 for (y=0; y<height; y++)
4121 {
4122 src_pixel = src_row;
4123 dst_pixel = dst_row;
4124 for (x=0; x<width; x++)
4125 {
4126 /* FIXME: This could probably be faster without memcpy. */
4127 memcpy(dst_pixel, src_pixel, bytesperpixel);
4128 dst_pixel += bytesperpixel;
4129 src_pixel += src_x_offset;
4130 }
4131 src_row += src_y_offset;
4132 dst_row += dst_lock.Stride;
4133 }
4134
4135 GdipBitmapUnlockBits(new_bitmap, &dst_lock);
4136 }
4137
4138 GdipBitmapUnlockBits(bitmap, &src_lock);
4139 }
4140
4141 if (stat == Ok)
4142 move_bitmap(bitmap, new_bitmap, FALSE);
4143 else
4144 GdipDisposeImage((GpImage*)new_bitmap);
4145
4146 return stat;
4147 }
4148
4149 /*****************************************************************************
4150 * GdipConvertToEmfPlusToFile [GDIPLUS.@]
4151 */
4152
4153 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
4154 GpMetafile* metafile, BOOL* conversionSuccess,
4155 const WCHAR* filename, EmfType emfType,
4156 const WCHAR* description, GpMetafile** out_metafile)
4157 {
4158 FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
4159 return NotImplemented;
4160 }
Maarten's multimedia branch