?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Get rid of some unused prototypes.
[wine/multimedia.git] / dlls / gdiplus / image.c
bloba4dade8dd808a55880934ef92c00420681aa074e
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 GdipGetPropertyCount(GpImage *image, UINT *num)
2394 {
2395 TRACE("(%p, %p)\n", image, num);
2396
2397 if (!image || !num) return InvalidParameter;
2398
2399 *num = 0;
2400
2401 if (image->type == ImageTypeBitmap)
2402 {
2403 if (((GpBitmap *)image)->metadata_reader)
2404 IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2405 }
2406
2407 return Ok;
2408 }
2409
2410 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2411 {
2412 HRESULT hr;
2413 IWICMetadataReader *reader;
2414 IWICEnumMetadataItem *enumerator;
2415 UINT prop_count, i, items_returned;
2416
2417 TRACE("(%p, %u, %p)\n", image, num, list);
2418
2419 if (!image || !list) return InvalidParameter;
2420
2421 if (image->type != ImageTypeBitmap)
2422 {
2423 FIXME("Not implemented for type %d\n", image->type);
2424 return NotImplemented;
2425 }
2426
2427 reader = ((GpBitmap *)image)->metadata_reader;
2428 if (!reader)
2429 {
2430 if (num != 0) return InvalidParameter;
2431 return Ok;
2432 }
2433
2434 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2435 if (FAILED(hr)) return hresult_to_status(hr);
2436
2437 if (num != prop_count) return InvalidParameter;
2438
2439 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2440 if (FAILED(hr)) return hresult_to_status(hr);
2441
2442 IWICEnumMetadataItem_Reset(enumerator);
2443
2444 for (i = 0; i < num; i++)
2445 {
2446 PROPVARIANT id;
2447
2448 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2449 if (hr != S_OK) break;
2450
2451 if (id.vt != VT_UI2)
2452 {
2453 FIXME("not supported propvariant type for id: %u\n", id.vt);
2454 list[i] = 0;
2455 continue;
2456 }
2457 list[i] = id.u.uiVal;
2458 }
2459
2460 IWICEnumMetadataItem_Release(enumerator);
2461
2462 return hr == S_OK ? Ok : hresult_to_status(hr);
2463 }
2464
2465 static UINT propvariant_size(PROPVARIANT *value)
2466 {
2467 switch (value->vt & ~VT_VECTOR)
2468 {
2469 case VT_EMPTY:
2470 return 0;
2471 case VT_I1:
2472 case VT_UI1:
2473 if (!(value->vt & VT_VECTOR)) return 1;
2474 return value->u.caub.cElems;
2475 case VT_I2:
2476 case VT_UI2:
2477 if (!(value->vt & VT_VECTOR)) return 2;
2478 return value->u.caui.cElems * 2;
2479 case VT_I4:
2480 case VT_UI4:
2481 case VT_R4:
2482 if (!(value->vt & VT_VECTOR)) return 4;
2483 return value->u.caul.cElems * 4;
2484 case VT_I8:
2485 case VT_UI8:
2486 case VT_R8:
2487 if (!(value->vt & VT_VECTOR)) return 8;
2488 return value->u.cauh.cElems * 8;
2489 case VT_LPSTR:
2490 return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2491 case VT_BLOB:
2492 return value->u.blob.cbSize;
2493 default:
2494 FIXME("not supported variant type %d\n", value->vt);
2495 return 0;
2496 }
2497 }
2498
2499 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2500 {
2501 HRESULT hr;
2502 IWICMetadataReader *reader;
2503 PROPVARIANT id, value;
2504
2505 TRACE("(%p,%#x,%p)\n", image, propid, size);
2506
2507 if (!size || !image) return InvalidParameter;
2508
2509 if (image->type != ImageTypeBitmap)
2510 {
2511 FIXME("Not implemented for type %d\n", image->type);
2512 return NotImplemented;
2513 }
2514
2515 reader = ((GpBitmap *)image)->metadata_reader;
2516 if (!reader) return PropertyNotFound;
2517
2518 id.vt = VT_UI2;
2519 id.u.uiVal = propid;
2520 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2521 if (FAILED(hr)) return PropertyNotFound;
2522
2523 *size = propvariant_size(&value);
2524 if (*size) *size += sizeof(PropertyItem);
2525 PropVariantClear(&value);
2526
2527 return Ok;
2528 }
2529
2530 #ifndef PropertyTagTypeSByte
2531 #define PropertyTagTypeSByte 6
2532 #define PropertyTagTypeSShort 8
2533 #define PropertyTagTypeFloat 11
2534 #define PropertyTagTypeDouble 12
2535 #endif
2536
2537 static UINT vt_to_itemtype(UINT vt)
2538 {
2539 static const struct
2540 {
2541 UINT vt, type;
2542 } vt2type[] =
2543 {
2544 { VT_I1, PropertyTagTypeSByte },
2545 { VT_UI1, PropertyTagTypeByte },
2546 { VT_I2, PropertyTagTypeSShort },
2547 { VT_UI2, PropertyTagTypeShort },
2548 { VT_I4, PropertyTagTypeSLONG },
2549 { VT_UI4, PropertyTagTypeLong },
2550 { VT_I8, PropertyTagTypeSRational },
2551 { VT_UI8, PropertyTagTypeRational },
2552 { VT_R4, PropertyTagTypeFloat },
2553 { VT_R8, PropertyTagTypeDouble },
2554 { VT_LPSTR, PropertyTagTypeASCII },
2555 { VT_BLOB, PropertyTagTypeUndefined }
2556 };
2557 UINT i;
2558 for (i = 0; i < sizeof(vt2type)/sizeof(vt2type[0]); i++)
2559 {
2560 if (vt2type[i].vt == vt) return vt2type[i].type;
2561 }
2562 FIXME("not supported variant type %u\n", vt);
2563 return 0;
2564 }
2565
2566 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2567 UINT size, PROPID id)
2568 {
2569 UINT item_size, item_type;
2570
2571 item_size = propvariant_size(value);
2572 if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2573
2574 item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2575 if (!item_type) return InvalidParameter;
2576
2577 item->value = item + 1;
2578
2579 switch (value->vt & ~VT_VECTOR)
2580 {
2581 case VT_I1:
2582 case VT_UI1:
2583 if (!(value->vt & VT_VECTOR))
2584 *(BYTE *)item->value = value->u.bVal;
2585 else
2586 memcpy(item->value, value->u.caub.pElems, item_size);
2587 break;
2588 case VT_I2:
2589 case VT_UI2:
2590 if (!(value->vt & VT_VECTOR))
2591 *(USHORT *)item->value = value->u.uiVal;
2592 else
2593 memcpy(item->value, value->u.caui.pElems, item_size);
2594 break;
2595 case VT_I4:
2596 case VT_UI4:
2597 case VT_R4:
2598 if (!(value->vt & VT_VECTOR))
2599 *(ULONG *)item->value = value->u.ulVal;
2600 else
2601 memcpy(item->value, value->u.caul.pElems, item_size);
2602 break;
2603 case VT_I8:
2604 case VT_UI8:
2605 case VT_R8:
2606 if (!(value->vt & VT_VECTOR))
2607 *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2608 else
2609 memcpy(item->value, value->u.cauh.pElems, item_size);
2610 break;
2611 case VT_LPSTR:
2612 memcpy(item->value, value->u.pszVal, item_size);
2613 break;
2614 case VT_BLOB:
2615 memcpy(item->value, value->u.blob.pBlobData, item_size);
2616 break;
2617 default:
2618 FIXME("not supported variant type %d\n", value->vt);
2619 return InvalidParameter;
2620 }
2621
2622 item->length = item_size;
2623 item->type = item_type;
2624 item->id = id;
2625
2626 return Ok;
2627 }
2628
2629 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2630 PropertyItem *buffer)
2631 {
2632 GpStatus stat;
2633 HRESULT hr;
2634 IWICMetadataReader *reader;
2635 PROPVARIANT id, value;
2636
2637 TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2638
2639 if (!image || !buffer) return InvalidParameter;
2640
2641 if (image->type != ImageTypeBitmap)
2642 {
2643 FIXME("Not implemented for type %d\n", image->type);
2644 return NotImplemented;
2645 }
2646
2647 reader = ((GpBitmap *)image)->metadata_reader;
2648 if (!reader) return PropertyNotFound;
2649
2650 id.vt = VT_UI2;
2651 id.u.uiVal = propid;
2652 hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2653 if (FAILED(hr)) return PropertyNotFound;
2654
2655 stat = propvariant_to_item(&value, buffer, size, propid);
2656 PropVariantClear(&value);
2657
2658 return stat;
2659 }
2660
2661 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2662 {
2663 HRESULT hr;
2664 IWICMetadataReader *reader;
2665 IWICEnumMetadataItem *enumerator;
2666 UINT prop_count, prop_size, i;
2667 PROPVARIANT id, value;
2668
2669 TRACE("(%p,%p,%p)\n", image, size, count);
2670
2671 if (!image || !size || !count) return InvalidParameter;
2672
2673 if (image->type != ImageTypeBitmap)
2674 {
2675 FIXME("Not implemented for type %d\n", image->type);
2676 return NotImplemented;
2677 }
2678
2679 reader = ((GpBitmap *)image)->metadata_reader;
2680 if (!reader) return PropertyNotFound;
2681
2682 hr = IWICMetadataReader_GetCount(reader, &prop_count);
2683 if (FAILED(hr)) return hresult_to_status(hr);
2684
2685 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2686 if (FAILED(hr)) return hresult_to_status(hr);
2687
2688 IWICEnumMetadataItem_Reset(enumerator);
2689
2690 prop_size = 0;
2691
2692 PropVariantInit(&id);
2693 PropVariantInit(&value);
2694
2695 for (i = 0; i < prop_count; i++)
2696 {
2697 UINT items_returned, item_size;
2698
2699 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2700 if (hr != S_OK) break;
2701
2702 item_size = propvariant_size(&value);
2703 if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2704
2705 PropVariantClear(&id);
2706 PropVariantClear(&value);
2707 }
2708
2709 IWICEnumMetadataItem_Release(enumerator);
2710
2711 if (hr != S_OK) return PropertyNotFound;
2712
2713 *count = prop_count;
2714 *size = prop_size;
2715 return Ok;
2716 }
2717
2718 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2719 UINT count, PropertyItem *buf)
2720 {
2721 GpStatus status;
2722 HRESULT hr;
2723 IWICMetadataReader *reader;
2724 IWICEnumMetadataItem *enumerator;
2725 UINT prop_count, prop_size, i;
2726 PROPVARIANT id, value;
2727 char *item_value;
2728
2729 TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2730
2731 if (!image || !buf) return InvalidParameter;
2732
2733 if (image->type != ImageTypeBitmap)
2734 {
2735 FIXME("Not implemented for type %d\n", image->type);
2736 return NotImplemented;
2737 }
2738
2739 status = GdipGetPropertySize(image, &prop_size, &prop_count);
2740 if (status != Ok) return status;
2741
2742 if (prop_count != count || prop_size != size) return InvalidParameter;
2743
2744 reader = ((GpBitmap *)image)->metadata_reader;
2745 if (!reader) return PropertyNotFound;
2746
2747 hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2748 if (FAILED(hr)) return hresult_to_status(hr);
2749
2750 IWICEnumMetadataItem_Reset(enumerator);
2751
2752 item_value = (char *)(buf + prop_count);
2753
2754 PropVariantInit(&id);
2755 PropVariantInit(&value);
2756
2757 for (i = 0; i < prop_count; i++)
2758 {
2759 PropertyItem *item;
2760 UINT items_returned, item_size;
2761
2762 hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2763 if (hr != S_OK) break;
2764
2765 if (id.vt != VT_UI2)
2766 {
2767 FIXME("not supported propvariant type for id: %u\n", id.vt);
2768 continue;
2769 }
2770
2771 item_size = propvariant_size(&value);
2772 if (item_size)
2773 {
2774 item = HeapAlloc(GetProcessHeap(), 0, item_size + sizeof(*item));
2775
2776 propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2777 buf[i].id = item->id;
2778 buf[i].type = item->type;
2779 buf[i].length = item_size;
2780 buf[i].value = item_value;
2781 memcpy(item_value, item->value, item_size);
2782 item_value += item_size;
2783
2784 HeapFree(GetProcessHeap(), 0, item);
2785 }
2786
2787 PropVariantClear(&id);
2788 PropVariantClear(&value);
2789 }
2790
2791 IWICEnumMetadataItem_Release(enumerator);
2792
2793 if (hr != S_OK) return PropertyNotFound;
2794
2795 return Ok;
2796 }
2797
2798 struct image_format_dimension
2799 {
2800 const GUID *format;
2801 const GUID *dimension;
2802 };
2803
2804 static const struct image_format_dimension image_format_dimensions[] =
2805 {
2806 {&ImageFormatGIF, &FrameDimensionTime},
2807 {&ImageFormatIcon, &FrameDimensionResolution},
2808 {NULL}
2809 };
2810
2811 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2812 GDIPCONST GUID* dimensionID, UINT* count)
2813 {
2814 TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2815
2816 if(!image || !count)
2817 return InvalidParameter;
2818
2819 if (!dimensionID ||
2820 IsEqualGUID(dimensionID, &image->format) ||
2821 IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2822 IsEqualGUID(dimensionID, &FrameDimensionTime))
2823 {
2824 *count = image->frame_count;
2825 return Ok;
2826 }
2827
2828 return InvalidParameter;
2829 }
2830
2831 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2832 UINT* count)
2833 {
2834 TRACE("(%p, %p)\n", image, count);
2835
2836 /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2837
2838 if(!image || !count)
2839 return InvalidParameter;
2840
2841 *count = 1;
2842
2843 return Ok;
2844 }
2845
2846 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2847 GUID* dimensionIDs, UINT count)
2848 {
2849 int i;
2850 const GUID *result=NULL;
2851
2852 TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2853
2854 if(!image || !dimensionIDs || count != 1)
2855 return InvalidParameter;
2856
2857 for (i=0; image_format_dimensions[i].format; i++)
2858 {
2859 if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2860 {
2861 result = image_format_dimensions[i].dimension;
2862 break;
2863 }
2864 }
2865
2866 if (!result)
2867 result = &FrameDimensionPage;
2868
2869 memcpy(dimensionIDs, result, sizeof(GUID));
2870
2871 return Ok;
2872 }
2873
2874 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2875 GpImage **image)
2876 {
2877 GpStatus stat;
2878 IStream *stream;
2879
2880 TRACE("(%s) %p\n", debugstr_w(filename), image);
2881
2882 if (!filename || !image)
2883 return InvalidParameter;
2884
2885 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2886
2887 if (stat != Ok)
2888 return stat;
2889
2890 stat = GdipLoadImageFromStream(stream, image);
2891
2892 IStream_Release(stream);
2893
2894 return stat;
2895 }
2896
2897 /* FIXME: no icm handling */
2898 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2899 {
2900 TRACE("(%s) %p\n", debugstr_w(filename), image);
2901
2902 return GdipLoadImageFromFile(filename, image);
2903 }
2904
2905 static const WICPixelFormatGUID * const wic_pixel_formats[] = {
2906 &GUID_WICPixelFormat16bppBGR555,
2907 &GUID_WICPixelFormat24bppBGR,
2908 &GUID_WICPixelFormat32bppBGR,
2909 &GUID_WICPixelFormat32bppBGRA,
2910 &GUID_WICPixelFormat32bppPBGRA,
2911 NULL
2912 };
2913
2914 static const PixelFormat wic_gdip_formats[] = {
2915 PixelFormat16bppRGB555,
2916 PixelFormat24bppRGB,
2917 PixelFormat32bppRGB,
2918 PixelFormat32bppARGB,
2919 PixelFormat32bppPARGB,
2920 };
2921
2922 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
2923 {
2924 GpStatus status=Ok;
2925 GpBitmap *bitmap;
2926 HRESULT hr;
2927 IWICBitmapDecoder *decoder;
2928 IWICBitmapFrameDecode *frame;
2929 IWICBitmapSource *source=NULL;
2930 IWICMetadataBlockReader *block_reader;
2931 WICPixelFormatGUID wic_format;
2932 PixelFormat gdip_format=0;
2933 int i;
2934 UINT width, height, frame_count;
2935 BitmapData lockeddata;
2936 WICRect wrc;
2937 HRESULT initresult;
2938
2939 initresult = CoInitialize(NULL);
2940
2941 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2942 &IID_IWICBitmapDecoder, (void**)&decoder);
2943 if (FAILED(hr)) goto end;
2944
2945 hr = IWICBitmapDecoder_Initialize(decoder, stream, WICDecodeMetadataCacheOnLoad);
2946 if (SUCCEEDED(hr))
2947 {
2948 IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
2949 hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
2950 }
2951
2952 if (SUCCEEDED(hr)) /* got frame */
2953 {
2954 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
2955
2956 if (SUCCEEDED(hr))
2957 {
2958 IWICBitmapSource *bmp_source;
2959 IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICBitmapSource, (void **)&bmp_source);
2960
2961 for (i=0; wic_pixel_formats[i]; i++)
2962 {
2963 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
2964 {
2965 source = bmp_source;
2966 gdip_format = wic_gdip_formats[i];
2967 break;
2968 }
2969 }
2970 if (!source)
2971 {
2972 /* unknown format; fall back on 32bppARGB */
2973 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, bmp_source, &source);
2974 gdip_format = PixelFormat32bppARGB;
2975 IWICBitmapSource_Release(bmp_source);
2976 }
2977 }
2978
2979 if (SUCCEEDED(hr)) /* got source */
2980 {
2981 hr = IWICBitmapSource_GetSize(source, &width, &height);
2982
2983 if (SUCCEEDED(hr))
2984 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
2985 NULL, &bitmap);
2986
2987 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
2988 {
2989 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
2990 gdip_format, &lockeddata);
2991 if (status == Ok) /* locked bitmap */
2992 {
2993 wrc.X = 0;
2994 wrc.Width = width;
2995 wrc.Height = 1;
2996 for (i=0; i<height; i++)
2997 {
2998 wrc.Y = i;
2999 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
3000 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
3001 if (FAILED(hr)) break;
3002 }
3003
3004 GdipBitmapUnlockBits(bitmap, &lockeddata);
3005 }
3006
3007 if (SUCCEEDED(hr) && status == Ok)
3008 *image = (GpImage*)bitmap;
3009 else
3010 {
3011 *image = NULL;
3012 GdipDisposeImage((GpImage*)bitmap);
3013 }
3014
3015 if (SUCCEEDED(hr) && status == Ok)
3016 {
3017 double dpix, dpiy;
3018 hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
3019 if (SUCCEEDED(hr))
3020 {
3021 bitmap->image.xres = dpix;
3022 bitmap->image.yres = dpiy;
3023 }
3024 hr = S_OK;
3025 }
3026 }
3027
3028 IWICBitmapSource_Release(source);
3029 }
3030
3031 bitmap->metadata_reader = NULL;
3032 if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
3033 {
3034 UINT block_count = 0;
3035 if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
3036 IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
3037 IWICMetadataBlockReader_Release(block_reader);
3038 }
3039
3040 IWICBitmapFrameDecode_Release(frame);
3041 }
3042
3043 IWICBitmapDecoder_Release(decoder);
3044
3045 end:
3046 if (SUCCEEDED(initresult)) CoUninitialize();
3047
3048 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
3049
3050 if (status == Ok)
3051 {
3052 /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
3053 bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI|ImageFlagsColorSpaceRGB;
3054 bitmap->image.frame_count = frame_count;
3055 bitmap->image.current_frame = active_frame;
3056 bitmap->image.stream = stream;
3057 /* Pin the source stream */
3058 IStream_AddRef(stream);
3059 }
3060
3061 return status;
3062 }
3063
3064 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3065 {
3066 return decode_image_wic(stream, &CLSID_WICIcoDecoder, active_frame, image);
3067 }
3068
3069 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3070 {
3071 GpStatus status;
3072 GpBitmap* bitmap;
3073
3074 status = decode_image_wic(stream, &CLSID_WICBmpDecoder, active_frame, image);
3075
3076 bitmap = (GpBitmap*)*image;
3077
3078 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
3079 {
3080 /* WIC supports bmp files with alpha, but gdiplus does not */
3081 bitmap->format = PixelFormat32bppRGB;
3082 }
3083
3084 return status;
3085 }
3086
3087 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3088 {
3089 return decode_image_wic(stream, &CLSID_WICJpegDecoder, active_frame, image);
3090 }
3091
3092 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3093 {
3094 return decode_image_wic(stream, &CLSID_WICPngDecoder, active_frame, image);
3095 }
3096
3097 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3098 {
3099 return decode_image_wic(stream, &CLSID_WICGifDecoder, active_frame, image);
3100 }
3101
3102 static GpStatus decode_image_tiff(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3103 {
3104 return decode_image_wic(stream, &CLSID_WICTiffDecoder, active_frame, image);
3105 }
3106
3107 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, UINT active_frame, GpImage **image)
3108 {
3109 IPicture *pic;
3110
3111 TRACE("%p %p\n", stream, image);
3112
3113 if(!stream || !image)
3114 return InvalidParameter;
3115
3116 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
3117 (LPVOID*) &pic) != S_OK){
3118 TRACE("Could not load picture\n");
3119 return GenericError;
3120 }
3121
3122 /* FIXME: missing initialization code */
3123 *image = GdipAlloc(sizeof(GpMetafile));
3124 if(!*image) return OutOfMemory;
3125 (*image)->type = ImageTypeMetafile;
3126 (*image)->stream = NULL;
3127 (*image)->picture = pic;
3128 (*image)->flags = ImageFlagsNone;
3129 (*image)->frame_count = 1;
3130 (*image)->current_frame = 0;
3131 (*image)->palette_flags = 0;
3132 (*image)->palette_count = 0;
3133 (*image)->palette_size = 0;
3134 (*image)->palette_entries = NULL;
3135
3136 TRACE("<-- %p\n", *image);
3137
3138 return Ok;
3139 }
3140
3141 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
3142 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
3143
3144 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, UINT active_frame, GpImage **image);
3145
3146 typedef struct image_codec {
3147 ImageCodecInfo info;
3148 encode_image_func encode_func;
3149 decode_image_func decode_func;
3150 } image_codec;
3151
3152 typedef enum {
3153 BMP,
3154 JPEG,
3155 GIF,
3156 TIFF,
3157 EMF,
3158 WMF,
3159 PNG,
3160 ICO,
3161 NUM_CODECS
3162 } ImageFormat;
3163
3164 static const struct image_codec codecs[NUM_CODECS];
3165
3166 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
3167 {
3168 BYTE signature[8];
3169 const BYTE *pattern, *mask;
3170 LARGE_INTEGER seek;
3171 HRESULT hr;
3172 UINT bytesread;
3173 int i, j, sig;
3174
3175 /* seek to the start of the stream */
3176 seek.QuadPart = 0;
3177 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3178 if (FAILED(hr)) return hresult_to_status(hr);
3179
3180 /* read the first 8 bytes */
3181 /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
3182 hr = IStream_Read(stream, signature, 8, &bytesread);
3183 if (FAILED(hr)) return hresult_to_status(hr);
3184 if (hr == S_FALSE || bytesread == 0) return GenericError;
3185
3186 for (i = 0; i < NUM_CODECS; i++) {
3187 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
3188 bytesread >= codecs[i].info.SigSize)
3189 {
3190 for (sig=0; sig<codecs[i].info.SigCount; sig++)
3191 {
3192 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
3193 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
3194 for (j=0; j<codecs[i].info.SigSize; j++)
3195 if ((signature[j] & mask[j]) != pattern[j])
3196 break;
3197 if (j == codecs[i].info.SigSize)
3198 {
3199 *result = &codecs[i];
3200 return Ok;
3201 }
3202 }
3203 }
3204 }
3205
3206 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
3207 signature[0],signature[1],signature[2],signature[3],
3208 signature[4],signature[5],signature[6],signature[7]);
3209
3210 return GenericError;
3211 }
3212
3213 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
3214 UINT frame)
3215 {
3216 GpStatus stat;
3217 LARGE_INTEGER seek;
3218 HRESULT hr;
3219 const struct image_codec *codec = NULL;
3220 IStream *stream;
3221 GpImage *new_image;
3222
3223 TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
3224
3225 if (!image || !dimensionID)
3226 return InvalidParameter;
3227
3228 if (frame >= image->frame_count)
3229 return InvalidParameter;
3230
3231 if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
3232 {
3233 WARN("invalid image type %d\n", image->type);
3234 return InvalidParameter;
3235 }
3236
3237 if (image->current_frame == frame)
3238 return Ok;
3239
3240 if (!image->stream)
3241 {
3242 TRACE("image doesn't have an associated stream\n");
3243 return Ok;
3244 }
3245
3246 hr = IStream_Clone(image->stream, &stream);
3247 if (FAILED(hr))
3248 {
3249 STATSTG statstg;
3250
3251 hr = IStream_Stat(image->stream, &statstg, STATFLAG_NOOPEN);
3252 if (FAILED(hr)) return hresult_to_status(hr);
3253
3254 stat = GdipCreateStreamOnFile(statstg.pwcsName, GENERIC_READ, &stream);
3255 if (stat != Ok) return stat;
3256 }
3257
3258 /* choose an appropriate image decoder */
3259 stat = get_decoder_info(stream, &codec);
3260 if (stat != Ok)
3261 {
3262 IStream_Release(stream);
3263 return stat;
3264 }
3265
3266 /* seek to the start of the stream */
3267 seek.QuadPart = 0;
3268 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3269 if (FAILED(hr))
3270 {
3271 IStream_Release(stream);
3272 return hresult_to_status(hr);
3273 }
3274
3275 /* call on the image decoder to do the real work */
3276 stat = codec->decode_func(stream, &codec->info.Clsid, frame, &new_image);
3277
3278 if (stat == Ok)
3279 {
3280 memcpy(&new_image->format, &codec->info.FormatID, sizeof(GUID));
3281 free_image_data(image);
3282 if (image->type == ImageTypeBitmap)
3283 *(GpBitmap *)image = *(GpBitmap *)new_image;
3284 else if (image->type == ImageTypeMetafile)
3285 *(GpMetafile *)image = *(GpMetafile *)new_image;
3286 new_image->type = ~0;
3287 GdipFree(new_image);
3288 return Ok;
3289 }
3290
3291 IStream_Release(stream);
3292 return stat;
3293 }
3294
3295 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
3296 {
3297 GpStatus stat;
3298 LARGE_INTEGER seek;
3299 HRESULT hr;
3300 const struct image_codec *codec=NULL;
3301
3302 /* choose an appropriate image decoder */
3303 stat = get_decoder_info(stream, &codec);
3304 if (stat != Ok) return stat;
3305
3306 /* seek to the start of the stream */
3307 seek.QuadPart = 0;
3308 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
3309 if (FAILED(hr)) return hresult_to_status(hr);
3310
3311 /* call on the image decoder to do the real work */
3312 stat = codec->decode_func(stream, &codec->info.Clsid, 0, image);
3313
3314 /* take note of the original data format */
3315 if (stat == Ok)
3316 {
3317 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
3318 return Ok;
3319 }
3320
3321 return stat;
3322 }
3323
3324 /* FIXME: no ICM */
3325 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
3326 {
3327 TRACE("%p %p\n", stream, image);
3328
3329 return GdipLoadImageFromStream(stream, image);
3330 }
3331
3332 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
3333 {
3334 static int calls;
3335
3336 TRACE("(%p,%u)\n", image, propId);
3337
3338 if(!image)
3339 return InvalidParameter;
3340
3341 if(!(calls++))
3342 FIXME("not implemented\n");
3343
3344 return NotImplemented;
3345 }
3346
3347 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
3348 {
3349 static int calls;
3350
3351 TRACE("(%p,%p)\n", image, item);
3352
3353 if(!(calls++))
3354 FIXME("not implemented\n");
3355
3356 return NotImplemented;
3357 }
3358
3359 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
3360 GDIPCONST CLSID *clsidEncoder,
3361 GDIPCONST EncoderParameters *encoderParams)
3362 {
3363 GpStatus stat;
3364 IStream *stream;
3365
3366 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
3367
3368 if (!image || !filename|| !clsidEncoder)
3369 return InvalidParameter;
3370
3371 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
3372 if (stat != Ok)
3373 return GenericError;
3374
3375 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
3376
3377 IStream_Release(stream);
3378 return stat;
3379 }
3380
3381 /*************************************************************************
3382 * Encoding functions -
3383 * These functions encode an image in different image file formats.
3384 */
3385 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
3386 #define BITMAP_FORMAT_JPEG 0xd8ff
3387 #define BITMAP_FORMAT_GIF 0x4947
3388 #define BITMAP_FORMAT_PNG 0x5089
3389 #define BITMAP_FORMAT_APM 0xcdd7
3390
3391 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
3392 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3393 {
3394 GpStatus stat;
3395 GpBitmap *bitmap;
3396 IWICBitmapEncoder *encoder;
3397 IWICBitmapFrameEncode *frameencode;
3398 IPropertyBag2 *encoderoptions;
3399 HRESULT hr;
3400 UINT width, height;
3401 PixelFormat gdipformat=0;
3402 WICPixelFormatGUID wicformat;
3403 GpRect rc;
3404 BitmapData lockeddata;
3405 HRESULT initresult;
3406 UINT i;
3407
3408 if (image->type != ImageTypeBitmap)
3409 return GenericError;
3410
3411 bitmap = (GpBitmap*)image;
3412
3413 GdipGetImageWidth(image, &width);
3414 GdipGetImageHeight(image, &height);
3415
3416 rc.X = 0;
3417 rc.Y = 0;
3418 rc.Width = width;
3419 rc.Height = height;
3420
3421 initresult = CoInitialize(NULL);
3422
3423 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
3424 &IID_IWICBitmapEncoder, (void**)&encoder);
3425 if (FAILED(hr))
3426 {
3427 if (SUCCEEDED(initresult)) CoUninitialize();
3428 return hresult_to_status(hr);
3429 }
3430
3431 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
3432
3433 if (SUCCEEDED(hr))
3434 {
3435 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
3436 }
3437
3438 if (SUCCEEDED(hr)) /* created frame */
3439 {
3440 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
3441
3442 if (SUCCEEDED(hr))
3443 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
3444
3445 if (SUCCEEDED(hr))
3446 /* FIXME: use the resolution from the image */
3447 hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
3448
3449 if (SUCCEEDED(hr))
3450 {
3451 for (i=0; wic_pixel_formats[i]; i++)
3452 {
3453 if (wic_gdip_formats[i] == bitmap->format)
3454 break;
3455 }
3456 if (wic_pixel_formats[i])
3457 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
3458 else
3459 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
3460
3461 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
3462
3463 for (i=0; wic_pixel_formats[i]; i++)
3464 {
3465 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
3466 break;
3467 }
3468 if (wic_pixel_formats[i])
3469 gdipformat = wic_gdip_formats[i];
3470 else
3471 {
3472 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
3473 hr = E_FAIL;
3474 }
3475 }
3476
3477 if (SUCCEEDED(hr))
3478 {
3479 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
3480 &lockeddata);
3481
3482 if (stat == Ok)
3483 {
3484 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
3485 BYTE *row;
3486
3487 /* write one row at a time in case stride is negative */
3488 row = lockeddata.Scan0;
3489 for (i=0; i<lockeddata.Height; i++)
3490 {
3491 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
3492 if (FAILED(hr)) break;
3493 row += lockeddata.Stride;
3494 }
3495
3496 GdipBitmapUnlockBits(bitmap, &lockeddata);
3497 }
3498 else
3499 hr = E_FAIL;
3500 }
3501
3502 if (SUCCEEDED(hr))
3503 hr = IWICBitmapFrameEncode_Commit(frameencode);
3504
3505 IWICBitmapFrameEncode_Release(frameencode);
3506 IPropertyBag2_Release(encoderoptions);
3507 }
3508
3509 if (SUCCEEDED(hr))
3510 hr = IWICBitmapEncoder_Commit(encoder);
3511
3512 IWICBitmapEncoder_Release(encoder);
3513
3514 if (SUCCEEDED(initresult)) CoUninitialize();
3515
3516 return hresult_to_status(hr);
3517 }
3518
3519 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
3520 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3521 {
3522 return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
3523 }
3524
3525 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
3526 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3527 {
3528 return encode_image_WIC(image, stream, &CLSID_WICTiffEncoder, params);
3529 }
3530
3531 static GpStatus encode_image_png(GpImage *image, IStream* stream,
3532 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3533 {
3534 return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
3535 }
3536
3537 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
3538 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3539 {
3540 return encode_image_WIC(image, stream, &CLSID_WICJpegEncoder, params);
3541 }
3542
3543 /*****************************************************************************
3544 * GdipSaveImageToStream [GDIPLUS.@]
3545 */
3546 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
3547 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
3548 {
3549 GpStatus stat;
3550 encode_image_func encode_image;
3551 int i;
3552
3553 TRACE("%p %p %p %p\n", image, stream, clsid, params);
3554
3555 if(!image || !stream)
3556 return InvalidParameter;
3557
3558 /* select correct encoder */
3559 encode_image = NULL;
3560 for (i = 0; i < NUM_CODECS; i++) {
3561 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
3562 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
3563 encode_image = codecs[i].encode_func;
3564 }
3565 if (encode_image == NULL)
3566 return UnknownImageFormat;
3567
3568 stat = encode_image(image, stream, clsid, params);
3569
3570 return stat;
3571 }
3572
3573 /*****************************************************************************
3574 * GdipSaveAdd [GDIPLUS.@]
3575 */
3576 GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
3577 {
3578 FIXME("(%p,%p): stub\n", image, params);
3579 return Ok;
3580 }
3581
3582 /*****************************************************************************
3583 * GdipGetImagePalette [GDIPLUS.@]
3584 */
3585 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
3586 {
3587 TRACE("(%p,%p,%i)\n", image, palette, size);
3588
3589 if (!image || !palette)
3590 return InvalidParameter;
3591
3592 if (size < (sizeof(UINT)*2+sizeof(ARGB)*image->palette_count))
3593 {
3594 TRACE("<-- InsufficientBuffer\n");
3595 return InsufficientBuffer;
3596 }
3597
3598 palette->Flags = image->palette_flags;
3599 palette->Count = image->palette_count;
3600 memcpy(palette->Entries, image->palette_entries, sizeof(ARGB)*image->palette_count);
3601
3602 return Ok;
3603 }
3604
3605 /*****************************************************************************
3606 * GdipSetImagePalette [GDIPLUS.@]
3607 */
3608 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
3609 GDIPCONST ColorPalette *palette)
3610 {
3611 TRACE("(%p,%p)\n", image, palette);
3612
3613 if(!image || !palette || palette->Count > 256)
3614 return InvalidParameter;
3615
3616 if (palette->Count > image->palette_size)
3617 {
3618 ARGB *new_palette;
3619
3620 new_palette = GdipAlloc(sizeof(ARGB) * palette->Count);
3621 if (!new_palette) return OutOfMemory;
3622
3623 GdipFree(image->palette_entries);
3624 image->palette_entries = new_palette;
3625 image->palette_size = palette->Count;
3626 }
3627
3628 image->palette_flags = palette->Flags;
3629 image->palette_count = palette->Count;
3630 memcpy(image->palette_entries, palette->Entries, sizeof(ARGB)*palette->Count);
3631
3632 return Ok;
3633 }
3634
3635 /*************************************************************************
3636 * Encoders -
3637 * Structures that represent which formats we support for encoding.
3638 */
3639
3640 /* ImageCodecInfo creation routines taken from libgdiplus */
3641 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
3642 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
3643 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
3644 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
3645 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
3646 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
3647
3648 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
3649 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
3650 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
3651 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
3652 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
3653 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
3654
3655 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
3656 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
3657 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
3658 static const WCHAR gif_format[] = {'G','I','F',0};
3659 static const BYTE gif_sig_pattern[4] = "GIF8";
3660 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3661
3662 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
3663 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
3664 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
3665 static const WCHAR tiff_format[] = {'T','I','F','F',0};
3666 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
3667 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3668
3669 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
3670 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
3671 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
3672 static const WCHAR emf_format[] = {'E','M','F',0};
3673 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
3674 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3675
3676 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
3677 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
3678 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
3679 static const WCHAR wmf_format[] = {'W','M','F',0};
3680 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
3681 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
3682
3683 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
3684 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
3685 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
3686 static const WCHAR png_format[] = {'P','N','G',0};
3687 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
3688 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3689
3690 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
3691 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
3692 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
3693 static const WCHAR ico_format[] = {'I','C','O',0};
3694 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
3695 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
3696
3697 static const struct image_codec codecs[NUM_CODECS] = {
3698 {
3699 { /* BMP */
3700 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3701 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3702 /* CodecName */ bmp_codecname,
3703 /* DllName */ NULL,
3704 /* FormatDescription */ bmp_format,
3705 /* FilenameExtension */ bmp_extension,
3706 /* MimeType */ bmp_mimetype,
3707 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3708 /* Version */ 1,
3709 /* SigCount */ 1,
3710 /* SigSize */ 2,
3711 /* SigPattern */ bmp_sig_pattern,
3712 /* SigMask */ bmp_sig_mask,
3713 },
3714 encode_image_BMP,
3715 decode_image_bmp
3716 },
3717 {
3718 { /* JPEG */
3719 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3720 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3721 /* CodecName */ jpeg_codecname,
3722 /* DllName */ NULL,
3723 /* FormatDescription */ jpeg_format,
3724 /* FilenameExtension */ jpeg_extension,
3725 /* MimeType */ jpeg_mimetype,
3726 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3727 /* Version */ 1,
3728 /* SigCount */ 1,
3729 /* SigSize */ 2,
3730 /* SigPattern */ jpeg_sig_pattern,
3731 /* SigMask */ jpeg_sig_mask,
3732 },
3733 encode_image_jpeg,
3734 decode_image_jpeg
3735 },
3736 {
3737 { /* GIF */
3738 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3739 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3740 /* CodecName */ gif_codecname,
3741 /* DllName */ NULL,
3742 /* FormatDescription */ gif_format,
3743 /* FilenameExtension */ gif_extension,
3744 /* MimeType */ gif_mimetype,
3745 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3746 /* Version */ 1,
3747 /* SigCount */ 1,
3748 /* SigSize */ 4,
3749 /* SigPattern */ gif_sig_pattern,
3750 /* SigMask */ gif_sig_mask,
3751 },
3752 NULL,
3753 decode_image_gif
3754 },
3755 {
3756 { /* TIFF */
3757 /* Clsid */ { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3758 /* FormatID */ { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3759 /* CodecName */ tiff_codecname,
3760 /* DllName */ NULL,
3761 /* FormatDescription */ tiff_format,
3762 /* FilenameExtension */ tiff_extension,
3763 /* MimeType */ tiff_mimetype,
3764 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3765 /* Version */ 1,
3766 /* SigCount */ 2,
3767 /* SigSize */ 4,
3768 /* SigPattern */ tiff_sig_pattern,
3769 /* SigMask */ tiff_sig_mask,
3770 },
3771 encode_image_tiff,
3772 decode_image_tiff
3773 },
3774 {
3775 { /* EMF */
3776 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3777 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3778 /* CodecName */ emf_codecname,
3779 /* DllName */ NULL,
3780 /* FormatDescription */ emf_format,
3781 /* FilenameExtension */ emf_extension,
3782 /* MimeType */ emf_mimetype,
3783 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3784 /* Version */ 1,
3785 /* SigCount */ 1,
3786 /* SigSize */ 4,
3787 /* SigPattern */ emf_sig_pattern,
3788 /* SigMask */ emf_sig_mask,
3789 },
3790 NULL,
3791 decode_image_olepicture_metafile
3792 },
3793 {
3794 { /* WMF */
3795 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3796 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3797 /* CodecName */ wmf_codecname,
3798 /* DllName */ NULL,
3799 /* FormatDescription */ wmf_format,
3800 /* FilenameExtension */ wmf_extension,
3801 /* MimeType */ wmf_mimetype,
3802 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
3803 /* Version */ 1,
3804 /* SigCount */ 1,
3805 /* SigSize */ 2,
3806 /* SigPattern */ wmf_sig_pattern,
3807 /* SigMask */ wmf_sig_mask,
3808 },
3809 NULL,
3810 decode_image_olepicture_metafile
3811 },
3812 {
3813 { /* PNG */
3814 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3815 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3816 /* CodecName */ png_codecname,
3817 /* DllName */ NULL,
3818 /* FormatDescription */ png_format,
3819 /* FilenameExtension */ png_extension,
3820 /* MimeType */ png_mimetype,
3821 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3822 /* Version */ 1,
3823 /* SigCount */ 1,
3824 /* SigSize */ 8,
3825 /* SigPattern */ png_sig_pattern,
3826 /* SigMask */ png_sig_mask,
3827 },
3828 encode_image_png,
3829 decode_image_png
3830 },
3831 {
3832 { /* ICO */
3833 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3834 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3835 /* CodecName */ ico_codecname,
3836 /* DllName */ NULL,
3837 /* FormatDescription */ ico_format,
3838 /* FilenameExtension */ ico_extension,
3839 /* MimeType */ ico_mimetype,
3840 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
3841 /* Version */ 1,
3842 /* SigCount */ 1,
3843 /* SigSize */ 4,
3844 /* SigPattern */ ico_sig_pattern,
3845 /* SigMask */ ico_sig_mask,
3846 },
3847 NULL,
3848 decode_image_icon
3849 },
3850 };
3851
3852 /*****************************************************************************
3853 * GdipGetImageDecodersSize [GDIPLUS.@]
3854 */
3855 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
3856 {
3857 int decoder_count=0;
3858 int i;
3859 TRACE("%p %p\n", numDecoders, size);
3860
3861 if (!numDecoders || !size)
3862 return InvalidParameter;
3863
3864 for (i=0; i<NUM_CODECS; i++)
3865 {
3866 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3867 decoder_count++;
3868 }
3869
3870 *numDecoders = decoder_count;
3871 *size = decoder_count * sizeof(ImageCodecInfo);
3872
3873 return Ok;
3874 }
3875
3876 /*****************************************************************************
3877 * GdipGetImageDecoders [GDIPLUS.@]
3878 */
3879 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
3880 {
3881 int i, decoder_count=0;
3882 TRACE("%u %u %p\n", numDecoders, size, decoders);
3883
3884 if (!decoders ||
3885 size != numDecoders * sizeof(ImageCodecInfo))
3886 return GenericError;
3887
3888 for (i=0; i<NUM_CODECS; i++)
3889 {
3890 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
3891 {
3892 if (decoder_count == numDecoders) return GenericError;
3893 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3894 decoder_count++;
3895 }
3896 }
3897
3898 if (decoder_count < numDecoders) return GenericError;
3899
3900 return Ok;
3901 }
3902
3903 /*****************************************************************************
3904 * GdipGetImageEncodersSize [GDIPLUS.@]
3905 */
3906 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
3907 {
3908 int encoder_count=0;
3909 int i;
3910 TRACE("%p %p\n", numEncoders, size);
3911
3912 if (!numEncoders || !size)
3913 return InvalidParameter;
3914
3915 for (i=0; i<NUM_CODECS; i++)
3916 {
3917 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3918 encoder_count++;
3919 }
3920
3921 *numEncoders = encoder_count;
3922 *size = encoder_count * sizeof(ImageCodecInfo);
3923
3924 return Ok;
3925 }
3926
3927 /*****************************************************************************
3928 * GdipGetImageEncoders [GDIPLUS.@]
3929 */
3930 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
3931 {
3932 int i, encoder_count=0;
3933 TRACE("%u %u %p\n", numEncoders, size, encoders);
3934
3935 if (!encoders ||
3936 size != numEncoders * sizeof(ImageCodecInfo))
3937 return GenericError;
3938
3939 for (i=0; i<NUM_CODECS; i++)
3940 {
3941 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
3942 {
3943 if (encoder_count == numEncoders) return GenericError;
3944 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
3945 encoder_count++;
3946 }
3947 }
3948
3949 if (encoder_count < numEncoders) return GenericError;
3950
3951 return Ok;
3952 }
3953
3954 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
3955 GDIPCONST CLSID* clsidEncoder, UINT *size)
3956 {
3957 static int calls;
3958
3959 TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
3960
3961 if(!(calls++))
3962 FIXME("not implemented\n");
3963
3964 *size = 0;
3965
3966 return NotImplemented;
3967 }
3968
3969 static PixelFormat get_16bpp_format(HBITMAP hbm)
3970 {
3971 BITMAPV4HEADER bmh;
3972 HDC hdc;
3973 PixelFormat result;
3974
3975 hdc = CreateCompatibleDC(NULL);
3976
3977 memset(&bmh, 0, sizeof(bmh));
3978 bmh.bV4Size = sizeof(bmh);
3979 bmh.bV4Width = 1;
3980 bmh.bV4Height = 1;
3981 bmh.bV4V4Compression = BI_BITFIELDS;
3982 bmh.bV4BitCount = 16;
3983
3984 GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
3985
3986 if (bmh.bV4RedMask == 0x7c00 &&
3987 bmh.bV4GreenMask == 0x3e0 &&
3988 bmh.bV4BlueMask == 0x1f)
3989 {
3990 result = PixelFormat16bppRGB555;
3991 }
3992 else if (bmh.bV4RedMask == 0xf800 &&
3993 bmh.bV4GreenMask == 0x7e0 &&
3994 bmh.bV4BlueMask == 0x1f)
3995 {
3996 result = PixelFormat16bppRGB565;
3997 }
3998 else
3999 {
4000 FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
4001 bmh.bV4GreenMask, bmh.bV4BlueMask);
4002 result = PixelFormatUndefined;
4003 }
4004
4005 DeleteDC(hdc);
4006
4007 return result;
4008 }
4009
4010 /*****************************************************************************
4011 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
4012 */
4013 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
4014 {
4015 BITMAP bm;
4016 GpStatus retval;
4017 PixelFormat format;
4018 BitmapData lockeddata;
4019 INT y;
4020
4021 TRACE("%p %p %p\n", hbm, hpal, bitmap);
4022
4023 if(!hbm || !bitmap)
4024 return InvalidParameter;
4025
4026 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
4027 return InvalidParameter;
4028
4029 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
4030 switch(bm.bmBitsPixel) {
4031 case 1:
4032 format = PixelFormat1bppIndexed;
4033 break;
4034 case 4:
4035 format = PixelFormat4bppIndexed;
4036 break;
4037 case 8:
4038 format = PixelFormat8bppIndexed;
4039 break;
4040 case 16:
4041 format = get_16bpp_format(hbm);
4042 if (format == PixelFormatUndefined)
4043 return InvalidParameter;
4044 break;
4045 case 24:
4046 format = PixelFormat24bppRGB;
4047 break;
4048 case 32:
4049 format = PixelFormat32bppRGB;
4050 break;
4051 case 48:
4052 format = PixelFormat48bppRGB;
4053 break;
4054 default:
4055 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
4056 return InvalidParameter;
4057 }
4058
4059 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
4060 format, NULL, bitmap);
4061
4062 if (retval == Ok)
4063 {
4064 retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
4065 format, &lockeddata);
4066 if (retval == Ok)
4067 {
4068 if (bm.bmBits)
4069 {
4070 for (y=0; y<bm.bmHeight; y++)
4071 {
4072 memcpy((BYTE*)lockeddata.Scan0+lockeddata.Stride*y,
4073 (BYTE*)bm.bmBits+bm.bmWidthBytes*(bm.bmHeight-1-y),
4074 bm.bmWidthBytes);
4075 }
4076 }
4077 else
4078 {
4079 HDC hdc;
4080 HBITMAP oldhbm;
4081 BITMAPINFO *pbmi;
4082 INT src_height, dst_stride;
4083 BYTE *dst_bits;
4084
4085 hdc = CreateCompatibleDC(NULL);
4086 oldhbm = SelectObject(hdc, hbm);
4087
4088 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
4089
4090 if (pbmi)
4091 {
4092 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
4093 pbmi->bmiHeader.biBitCount = 0;
4094
4095 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
4096
4097 src_height = abs(pbmi->bmiHeader.biHeight);
4098
4099 if (pbmi->bmiHeader.biHeight > 0)
4100 {
4101 dst_bits = (BYTE*)lockeddata.Scan0+lockeddata.Stride*(src_height-1);
4102 dst_stride = -lockeddata.Stride;
4103 }
4104 else
4105 {
4106 dst_bits = lockeddata.Scan0;
4107 dst_stride = lockeddata.Stride;
4108 }
4109
4110 for (y=0; y<src_height; y++)
4111 {
4112 GetDIBits(hdc, hbm, y, 1, dst_bits+dst_stride*y,
4113 pbmi, DIB_RGB_COLORS);
4114 }
4115
4116 GdipFree(pbmi);
4117 }
4118 else
4119 retval = OutOfMemory;
4120
4121 SelectObject(hdc, oldhbm);
4122 DeleteDC(hdc);
4123 }
4124
4125 GdipBitmapUnlockBits(*bitmap, &lockeddata);
4126 }
4127
4128 if (retval == Ok && hpal)
4129 {
4130 WORD num_palette_entries;
4131 PALETTEENTRY *palette_entries=NULL;
4132 ColorPalette *palette=NULL;
4133 int i;
4134
4135 if (!GetObjectW(hpal, sizeof(num_palette_entries), &num_palette_entries))
4136 retval = GenericError;
4137
4138 if (retval == Ok)
4139 {
4140 palette_entries = GdipAlloc(sizeof(PALETTEENTRY) * num_palette_entries);
4141 palette = GdipAlloc(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
4142
4143 if (!palette_entries || !palette)
4144 retval = OutOfMemory;
4145 }
4146
4147 if (retval == Ok)
4148 {
4149 if (!GetPaletteEntries(hpal, 0, num_palette_entries, palette_entries))
4150 retval = GenericError;
4151 }
4152
4153 if (retval == Ok)
4154 {
4155 palette->Flags = 0;
4156 palette->Count = num_palette_entries;
4157
4158 for (i=0; i<num_palette_entries; i++)
4159 {
4160 PALETTEENTRY * entry = &palette_entries[i];
4161 palette->Entries[i] = 0xff000000 | entry->peRed << 16 |
4162 entry->peGreen << 8 | entry->peBlue;
4163 }
4164
4165 retval = GdipSetImagePalette((GpImage*)*bitmap, palette);
4166 }
4167
4168 GdipFree(palette_entries);
4169 GdipFree(palette);
4170 }
4171
4172 if (retval != Ok)
4173 {
4174 GdipDisposeImage((GpImage*)*bitmap);
4175 *bitmap = NULL;
4176 }
4177 }
4178
4179 return retval;
4180 }
4181
4182 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
4183 {
4184 FIXME("(%p): stub\n", effect);
4185 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
4186 * in Windows's gdiplus */
4187 return NotImplemented;
4188 }
4189
4190 /*****************************************************************************
4191 * GdipSetEffectParameters [GDIPLUS.@]
4192 */
4193 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
4194 const VOID *params, const UINT size)
4195 {
4196 static int calls;
4197
4198 TRACE("(%p,%p,%u)\n", effect, params, size);
4199
4200 if(!(calls++))
4201 FIXME("not implemented\n");
4202
4203 return NotImplemented;
4204 }
4205
4206 /*****************************************************************************
4207 * GdipGetImageFlags [GDIPLUS.@]
4208 */
4209 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
4210 {
4211 TRACE("%p %p\n", image, flags);
4212
4213 if(!image || !flags)
4214 return InvalidParameter;
4215
4216 *flags = image->flags;
4217
4218 return Ok;
4219 }
4220
4221 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
4222 {
4223 TRACE("(%d, %p)\n", control, param);
4224
4225 switch(control){
4226 case TestControlForceBilinear:
4227 if(param)
4228 FIXME("TestControlForceBilinear not handled\n");
4229 break;
4230 case TestControlNoICM:
4231 if(param)
4232 FIXME("TestControlNoICM not handled\n");
4233 break;
4234 case TestControlGetBuildNumber:
4235 *((DWORD*)param) = 3102;
4236 break;
4237 }
4238
4239 return Ok;
4240 }
4241
4242 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
4243 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
4244 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
4245 GpMetafile **metafile)
4246 {
4247 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4248 frameUnit, debugstr_w(desc), metafile);
4249
4250 return NotImplemented;
4251 }
4252
4253 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
4254 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
4255 GDIPCONST WCHAR *desc, GpMetafile **metafile)
4256 {
4257 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
4258 frameUnit, debugstr_w(desc), metafile);
4259
4260 return NotImplemented;
4261 }
4262
4263 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
4264 {
4265 TRACE("%p\n", image);
4266
4267 return Ok;
4268 }
4269
4270 /*****************************************************************************
4271 * GdipGetImageThumbnail [GDIPLUS.@]
4272 */
4273 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
4274 GpImage **ret_image, GetThumbnailImageAbort cb,
4275 VOID * cb_data)
4276 {
4277 GpStatus stat;
4278 GpGraphics *graphics;
4279 UINT srcwidth, srcheight;
4280
4281 TRACE("(%p %u %u %p %p %p)\n",
4282 image, width, height, ret_image, cb, cb_data);
4283
4284 if (!image || !ret_image)
4285 return InvalidParameter;
4286
4287 if (!width) width = 120;
4288 if (!height) height = 120;
4289
4290 GdipGetImageWidth(image, &srcwidth);
4291 GdipGetImageHeight(image, &srcheight);
4292
4293 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB,
4294 NULL, (GpBitmap**)ret_image);
4295
4296 if (stat == Ok)
4297 {
4298 stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
4299
4300 if (stat == Ok)
4301 {
4302 stat = GdipDrawImageRectRectI(graphics, image,
4303 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
4304 NULL, NULL, NULL);
4305
4306 GdipDeleteGraphics(graphics);
4307 }
4308
4309 if (stat != Ok)
4310 {
4311 GdipDisposeImage(*ret_image);
4312 *ret_image = NULL;
4313 }
4314 }
4315
4316 return stat;
4317 }
4318
4319 /*****************************************************************************
4320 * GdipImageRotateFlip [GDIPLUS.@]
4321 */
4322 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
4323 {
4324 GpBitmap *new_bitmap;
4325 GpBitmap *bitmap;
4326 int bpp, bytesperpixel;
4327 int rotate_90, flip_x, flip_y;
4328 int src_x_offset, src_y_offset;
4329 LPBYTE src_origin;
4330 UINT x, y, width, height;
4331 BitmapData src_lock, dst_lock;
4332 GpStatus stat;
4333
4334 TRACE("(%p, %u)\n", image, type);
4335
4336 if (!image)
4337 return InvalidParameter;
4338
4339 rotate_90 = type&1;
4340 flip_x = (type&6) == 2 || (type&6) == 4;
4341 flip_y = (type&3) == 1 || (type&3) == 2;
4342
4343 if (image->type != ImageTypeBitmap)
4344 {
4345 FIXME("Not implemented for type %i\n", image->type);
4346 return NotImplemented;
4347 }
4348
4349 bitmap = (GpBitmap*)image;
4350 bpp = PIXELFORMATBPP(bitmap->format);
4351
4352 if (bpp < 8)
4353 {
4354 FIXME("Not implemented for %i bit images\n", bpp);
4355 return NotImplemented;
4356 }
4357
4358 if (rotate_90)
4359 {
4360 width = bitmap->height;
4361 height = bitmap->width;
4362 }
4363 else
4364 {
4365 width = bitmap->width;
4366 height = bitmap->height;
4367 }
4368
4369 bytesperpixel = bpp/8;
4370
4371 stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
4372
4373 if (stat != Ok)
4374 return stat;
4375
4376 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
4377
4378 if (stat == Ok)
4379 {
4380 stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
4381
4382 if (stat == Ok)
4383 {
4384 LPBYTE src_row, src_pixel;
4385 LPBYTE dst_row, dst_pixel;
4386
4387 src_origin = src_lock.Scan0;
4388 if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
4389 if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
4390
4391 if (rotate_90)
4392 {
4393 if (flip_y) src_x_offset = -src_lock.Stride;
4394 else src_x_offset = src_lock.Stride;
4395 if (flip_x) src_y_offset = -bytesperpixel;
4396 else src_y_offset = bytesperpixel;
4397 }
4398 else
4399 {
4400 if (flip_x) src_x_offset = -bytesperpixel;
4401 else src_x_offset = bytesperpixel;
4402 if (flip_y) src_y_offset = -src_lock.Stride;
4403 else src_y_offset = src_lock.Stride;
4404 }
4405
4406 src_row = src_origin;
4407 dst_row = dst_lock.Scan0;
4408 for (y=0; y<height; y++)
4409 {
4410 src_pixel = src_row;
4411 dst_pixel = dst_row;
4412 for (x=0; x<width; x++)
4413 {
4414 /* FIXME: This could probably be faster without memcpy. */
4415 memcpy(dst_pixel, src_pixel, bytesperpixel);
4416 dst_pixel += bytesperpixel;
4417 src_pixel += src_x_offset;
4418 }
4419 src_row += src_y_offset;
4420 dst_row += dst_lock.Stride;
4421 }
4422
4423 GdipBitmapUnlockBits(new_bitmap, &dst_lock);
4424 }
4425
4426 GdipBitmapUnlockBits(bitmap, &src_lock);
4427 }
4428
4429 if (stat == Ok)
4430 move_bitmap(bitmap, new_bitmap, FALSE);
4431 else
4432 GdipDisposeImage((GpImage*)new_bitmap);
4433
4434 return stat;
4435 }
4436
4437 /*****************************************************************************
4438 * GdipConvertToEmfPlusToFile [GDIPLUS.@]
4439 */
4440
4441 GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile(const GpGraphics* refGraphics,
4442 GpMetafile* metafile, BOOL* conversionSuccess,
4443 const WCHAR* filename, EmfType emfType,
4444 const WCHAR* description, GpMetafile** out_metafile)
4445 {
4446 FIXME("stub: %p, %p, %p, %p, %u, %p, %p\n", refGraphics, metafile, conversionSuccess, filename, emfType, description, out_metafile);
4447 return NotImplemented;
4448 }
Maarten's multimedia branch