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