projects / reactos.git / blob
? search:


3dbe4daf8beaf4f7c4a37123cc6758a8761fd706
[reactos.git] / reactos / dll / win32 / gdiplus / image.c
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_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
98 const BYTE *row, UINT x)
99 {
100 *r = *g = *b = row[x*2+1];
101 *a = 255;
102 }
103
104 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
105 const BYTE *row, UINT x)
106 {
107 WORD pixel = *((WORD*)(row)+x);
108 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
109 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
110 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
111 *a = 255;
112 }
113
114 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
115 const BYTE *row, UINT x)
116 {
117 WORD pixel = *((WORD*)(row)+x);
118 *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
119 *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
120 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
121 *a = 255;
122 }
123
124 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
125 const BYTE *row, UINT x)
126 {
127 WORD pixel = *((WORD*)(row)+x);
128 *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
129 *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
130 *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
131 if ((pixel&0x8000) == 0x8000)
132 *a = 255;
133 else
134 *a = 0;
135 }
136
137 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
138 const BYTE *row, UINT x)
139 {
140 *r = row[x*3+2];
141 *g = row[x*3+1];
142 *b = row[x*3];
143 *a = 255;
144 }
145
146 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
147 const BYTE *row, UINT x)
148 {
149 *r = row[x*4+2];
150 *g = row[x*4+1];
151 *b = row[x*4];
152 *a = 255;
153 }
154
155 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
156 const BYTE *row, UINT x)
157 {
158 *r = row[x*4+2];
159 *g = row[x*4+1];
160 *b = row[x*4];
161 *a = row[x*4+3];
162 }
163
164 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
165 const BYTE *row, UINT x)
166 {
167 *a = row[x*4+3];
168 if (*a == 0)
169 *r = *g = *b = 0;
170 else
171 {
172 *r = row[x*4+2] * 255 / *a;
173 *g = row[x*4+1] * 255 / *a;
174 *b = row[x*4] * 255 / *a;
175 }
176 }
177
178 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
179 const BYTE *row, UINT x)
180 {
181 *r = row[x*6+5];
182 *g = row[x*6+3];
183 *b = row[x*6+1];
184 *a = 255;
185 }
186
187 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
188 const BYTE *row, UINT x)
189 {
190 *r = row[x*8+5];
191 *g = row[x*8+3];
192 *b = row[x*8+1];
193 *a = row[x*8+7];
194 }
195
196 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
197 const BYTE *row, UINT x)
198 {
199 *a = row[x*8+7];
200 if (*a == 0)
201 *r = *g = *b = 0;
202 else
203 {
204 *r = row[x*8+5] * 255 / *a;
205 *g = row[x*8+3] * 255 / *a;
206 *b = row[x*8+1] * 255 / *a;
207 }
208 }
209
210 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
211 ARGB *color)
212 {
213 BYTE r, g, b, a;
214 BYTE *row;
215 TRACE("%p %d %d %p\n", bitmap, x, y, color);
216
217 if(!bitmap || !color ||
218 x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
219 return InvalidParameter;
220
221 row = bitmap->bits+bitmap->stride*y;
222
223 switch (bitmap->format)
224 {
225 case PixelFormat16bppGrayScale:
226 getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
227 break;
228 case PixelFormat16bppRGB555:
229 getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
230 break;
231 case PixelFormat16bppRGB565:
232 getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
233 break;
234 case PixelFormat16bppARGB1555:
235 getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
236 break;
237 case PixelFormat24bppRGB:
238 getpixel_24bppRGB(&r,&g,&b,&a,row,x);
239 break;
240 case PixelFormat32bppRGB:
241 getpixel_32bppRGB(&r,&g,&b,&a,row,x);
242 break;
243 case PixelFormat32bppARGB:
244 getpixel_32bppARGB(&r,&g,&b,&a,row,x);
245 break;
246 case PixelFormat32bppPARGB:
247 getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
248 break;
249 case PixelFormat48bppRGB:
250 getpixel_48bppRGB(&r,&g,&b,&a,row,x);
251 break;
252 case PixelFormat64bppARGB:
253 getpixel_64bppARGB(&r,&g,&b,&a,row,x);
254 break;
255 case PixelFormat64bppPARGB:
256 getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
257 break;
258 default:
259 FIXME("not implemented for format 0x%x\n", bitmap->format);
260 return NotImplemented;
261 }
262
263 *color = a<<24|r<<16|g<<8|b;
264
265 return Ok;
266 }
267
268 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
269 BYTE *row, UINT x)
270 {
271 *((WORD*)(row)+x) = (r+g+b)*85;
272 }
273
274 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
275 BYTE *row, UINT x)
276 {
277 *((WORD*)(row)+x) = (r<<7&0x7c00)|
278 (g<<2&0x03e0)|
279 (b>>3&0x001f);
280 }
281
282 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
283 BYTE *row, UINT x)
284 {
285 *((WORD*)(row)+x) = (r<<8&0xf800)|
286 (g<<3&0x07e0)|
287 (b>>3&0x001f);
288 }
289
290 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
291 BYTE *row, UINT x)
292 {
293 *((WORD*)(row)+x) = (a<<8&0x8000)|
294 (r<<7&0x7c00)|
295 (g<<2&0x03e0)|
296 (b>>3&0x001f);
297 }
298
299 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
300 BYTE *row, UINT x)
301 {
302 row[x*3+2] = r;
303 row[x*3+1] = g;
304 row[x*3] = b;
305 }
306
307 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
308 BYTE *row, UINT x)
309 {
310 *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
311 }
312
313 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
314 BYTE *row, UINT x)
315 {
316 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
317 }
318
319 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
320 BYTE *row, UINT x)
321 {
322 r = r * a / 255;
323 g = g * a / 255;
324 b = b * a / 255;
325 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
326 }
327
328 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
329 BYTE *row, UINT x)
330 {
331 row[x*6+5] = row[x*6+4] = r;
332 row[x*6+3] = row[x*6+2] = g;
333 row[x*6+1] = row[x*6] = b;
334 }
335
336 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
337 BYTE *row, UINT x)
338 {
339 UINT64 a64=a, r64=r, g64=g, b64=b;
340 *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
341 }
342
343 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
344 BYTE *row, UINT x)
345 {
346 UINT64 a64, r64, g64, b64;
347 a64 = a * 257;
348 r64 = r * a / 255;
349 g64 = g * a / 255;
350 b64 = b * a / 255;
351 *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
352 }
353
354 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
355 ARGB color)
356 {
357 BYTE a, r, g, b;
358 BYTE *row;
359 TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap, x, y, color);
360
361 if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
362 return InvalidParameter;
363
364 a = color>>24;
365 r = color>>16;
366 g = color>>8;
367 b = color;
368
369 row = bitmap->bits + bitmap->stride * y;
370
371 switch (bitmap->format)
372 {
373 case PixelFormat16bppGrayScale:
374 setpixel_16bppGrayScale(r,g,b,a,row,x);
375 break;
376 case PixelFormat16bppRGB555:
377 setpixel_16bppRGB555(r,g,b,a,row,x);
378 break;
379 case PixelFormat16bppRGB565:
380 setpixel_16bppRGB565(r,g,b,a,row,x);
381 break;
382 case PixelFormat16bppARGB1555:
383 setpixel_16bppARGB1555(r,g,b,a,row,x);
384 break;
385 case PixelFormat24bppRGB:
386 setpixel_24bppRGB(r,g,b,a,row,x);
387 break;
388 case PixelFormat32bppRGB:
389 setpixel_32bppRGB(r,g,b,a,row,x);
390 break;
391 case PixelFormat32bppARGB:
392 setpixel_32bppARGB(r,g,b,a,row,x);
393 break;
394 case PixelFormat32bppPARGB:
395 setpixel_32bppPARGB(r,g,b,a,row,x);
396 break;
397 case PixelFormat48bppRGB:
398 setpixel_48bppRGB(r,g,b,a,row,x);
399 break;
400 case PixelFormat64bppARGB:
401 setpixel_64bppARGB(r,g,b,a,row,x);
402 break;
403 case PixelFormat64bppPARGB:
404 setpixel_64bppPARGB(r,g,b,a,row,x);
405 break;
406 default:
407 FIXME("not implemented for format 0x%x\n", bitmap->format);
408 return NotImplemented;
409 }
410
411 return Ok;
412 }
413
414 /* This function returns a pointer to an array of pixels that represents the
415 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
416 * flags. It is correct behavior that a user who calls this function with write
417 * privileges can write to the whole bitmap (not just the area in rect).
418 *
419 * FIXME: only used portion of format is bits per pixel. */
420 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
421 UINT flags, PixelFormat format, BitmapData* lockeddata)
422 {
423 BOOL bm_is_selected;
424 INT stride, bitspp = PIXELFORMATBPP(format);
425 HDC hdc;
426 HBITMAP hbm, old = NULL;
427 BITMAPINFO *pbmi;
428 BYTE *buff = NULL;
429 UINT abs_height;
430 GpRect act_rect; /* actual rect to be used */
431
432 TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
433
434 if(!lockeddata || !bitmap)
435 return InvalidParameter;
436
437 if(rect){
438 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
439 (rect->Y + rect->Height > bitmap->height) || !flags)
440 return InvalidParameter;
441
442 act_rect = *rect;
443 }
444 else{
445 act_rect.X = act_rect.Y = 0;
446 act_rect.Width = bitmap->width;
447 act_rect.Height = bitmap->height;
448 }
449
450 if(flags & ImageLockModeUserInputBuf)
451 return NotImplemented;
452
453 if(bitmap->lockmode)
454 return WrongState;
455
456 if (bitmap->bits && bitmap->format == format)
457 {
458 /* no conversion is necessary; just use the bits directly */
459 lockeddata->Width = act_rect.Width;
460 lockeddata->Height = act_rect.Height;
461 lockeddata->PixelFormat = format;
462 lockeddata->Reserved = flags;
463 lockeddata->Stride = bitmap->stride;
464 lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
465 bitmap->stride * act_rect.Y;
466
467 bitmap->lockmode = flags;
468 bitmap->numlocks++;
469
470 return Ok;
471 }
472
473 hbm = bitmap->hbitmap;
474 hdc = bitmap->hdc;
475 bm_is_selected = (hdc != 0);
476
477 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
478 if (!pbmi)
479 return OutOfMemory;
480 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
481 pbmi->bmiHeader.biBitCount = 0;
482
483 if(!bm_is_selected){
484 hdc = CreateCompatibleDC(0);
485 old = SelectObject(hdc, hbm);
486 }
487
488 /* fill out bmi */
489 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
490
491 abs_height = abs(pbmi->bmiHeader.biHeight);
492 stride = pbmi->bmiHeader.biWidth * bitspp / 8;
493 stride = (stride + 3) & ~3;
494
495 buff = GdipAlloc(stride * abs_height);
496
497 pbmi->bmiHeader.biBitCount = bitspp;
498
499 if(buff)
500 GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
501
502 if(!bm_is_selected){
503 SelectObject(hdc, old);
504 DeleteDC(hdc);
505 }
506
507 if(!buff){
508 GdipFree(pbmi);
509 return OutOfMemory;
510 }
511
512 lockeddata->Width = act_rect.Width;
513 lockeddata->Height = act_rect.Height;
514 lockeddata->PixelFormat = format;
515 lockeddata->Reserved = flags;
516
517 if(pbmi->bmiHeader.biHeight > 0){
518 lockeddata->Stride = -stride;
519 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X +
520 stride * (abs_height - 1 - act_rect.Y);
521 }
522 else{
523 lockeddata->Stride = stride;
524 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
525 }
526
527 bitmap->lockmode = flags;
528 bitmap->numlocks++;
529
530 bitmap->bitmapbits = buff;
531
532 GdipFree(pbmi);
533 return Ok;
534 }
535
536 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
537 {
538 FIXME("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
539
540 return NotImplemented;
541 }
542
543 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
544 BitmapData* lockeddata)
545 {
546 HDC hdc;
547 HBITMAP hbm, old = NULL;
548 BOOL bm_is_selected;
549 BITMAPINFO *pbmi;
550
551 if(!bitmap || !lockeddata)
552 return InvalidParameter;
553
554 if(!bitmap->lockmode)
555 return WrongState;
556
557 if(lockeddata->Reserved & ImageLockModeUserInputBuf)
558 return NotImplemented;
559
560 if(lockeddata->Reserved & ImageLockModeRead){
561 if(!(--bitmap->numlocks))
562 bitmap->lockmode = 0;
563
564 GdipFree(bitmap->bitmapbits);
565 bitmap->bitmapbits = NULL;
566 return Ok;
567 }
568
569 if (!bitmap->bitmapbits)
570 {
571 /* we passed a direct reference; no need to do anything */
572 bitmap->lockmode = 0;
573 return Ok;
574 }
575
576 hbm = bitmap->hbitmap;
577 hdc = bitmap->hdc;
578 bm_is_selected = (hdc != 0);
579
580 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
581 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
582 pbmi->bmiHeader.biBitCount = 0;
583
584 if(!bm_is_selected){
585 hdc = CreateCompatibleDC(0);
586 old = SelectObject(hdc, hbm);
587 }
588
589 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
590 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
591 SetDIBits(hdc, hbm, 0, abs(pbmi->bmiHeader.biHeight),
592 bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
593
594 if(!bm_is_selected){
595 SelectObject(hdc, old);
596 DeleteDC(hdc);
597 }
598
599 GdipFree(pbmi);
600 GdipFree(bitmap->bitmapbits);
601 bitmap->bitmapbits = NULL;
602 bitmap->lockmode = 0;
603
604 return Ok;
605 }
606
607 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
608 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
609 {
610 BitmapData lockeddata_src, lockeddata_dst;
611 int i;
612 UINT row_size;
613 Rect area;
614 GpStatus stat;
615
616 TRACE("(%f,%f,%f,%f,%i,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
617
618 if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
619 x < 0 || y < 0 ||
620 x + width > srcBitmap->width || y + height > srcBitmap->height)
621 {
622 TRACE("<-- InvalidParameter\n");
623 return InvalidParameter;
624 }
625
626 if (format == PixelFormatDontCare)
627 format = srcBitmap->format;
628
629 area.X = roundr(x);
630 area.Y = roundr(y);
631 area.Width = roundr(width);
632 area.Height = roundr(height);
633
634 stat = GdipBitmapLockBits(srcBitmap, &area, ImageLockModeRead, format,
635 &lockeddata_src);
636 if (stat != Ok) return stat;
637
638 stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
639 0, lockeddata_src.PixelFormat, NULL, dstBitmap);
640 if (stat == Ok)
641 {
642 stat = GdipBitmapLockBits(*dstBitmap, NULL, ImageLockModeWrite,
643 lockeddata_src.PixelFormat, &lockeddata_dst);
644
645 if (stat == Ok)
646 {
647 /* copy the image data */
648 row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
649 for (i=0; i<lockeddata_src.Height; i++)
650 memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
651 (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
652 row_size);
653
654 GdipBitmapUnlockBits(*dstBitmap, &lockeddata_dst);
655 }
656
657 if (stat != Ok)
658 GdipDisposeImage((GpImage*)*dstBitmap);
659 }
660
661 GdipBitmapUnlockBits(srcBitmap, &lockeddata_src);
662
663 if (stat != Ok)
664 {
665 *dstBitmap = NULL;
666 }
667
668 return stat;
669 }
670
671 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
672 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
673 {
674 TRACE("(%i,%i,%i,%i,%i,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
675
676 return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
677 }
678
679 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
680 {
681 GpStatus stat = GenericError;
682
683 TRACE("%p, %p\n", image, cloneImage);
684
685 if (!image || !cloneImage)
686 return InvalidParameter;
687
688 if (image->picture)
689 {
690 IStream* stream;
691 HRESULT hr;
692 INT size;
693 LARGE_INTEGER move;
694
695 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
696 if (FAILED(hr))
697 return GenericError;
698
699 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
700 if(FAILED(hr))
701 {
702 WARN("Failed to save image on stream\n");
703 goto out;
704 }
705
706 /* Set seek pointer back to the beginning of the picture */
707 move.QuadPart = 0;
708 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
709 if (FAILED(hr))
710 goto out;
711
712 stat = GdipLoadImageFromStream(stream, cloneImage);
713 if (stat != Ok) WARN("Failed to load image from stream\n");
714
715 out:
716 IStream_Release(stream);
717 return stat;
718 }
719 else if (image->type == ImageTypeBitmap)
720 {
721 GpBitmap *bitmap = (GpBitmap*)image;
722 BitmapData lockeddata_src, lockeddata_dst;
723 int i;
724 UINT row_size;
725
726 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
727 &lockeddata_src);
728 if (stat != Ok) return stat;
729
730 stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
731 0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
732 if (stat == Ok)
733 {
734 stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
735 lockeddata_src.PixelFormat, &lockeddata_dst);
736
737 if (stat == Ok)
738 {
739 /* copy the image data */
740 row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
741 for (i=0; i<lockeddata_src.Height; i++)
742 memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
743 (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
744 row_size);
745
746 GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
747 }
748
749 if (stat != Ok)
750 GdipDisposeImage(*cloneImage);
751 }
752
753 GdipBitmapUnlockBits(bitmap, &lockeddata_src);
754
755 if (stat != Ok)
756 {
757 *cloneImage = NULL;
758 }
759 else memcpy(&(*cloneImage)->format, &image->format, sizeof(GUID));
760
761 return stat;
762 }
763 else
764 {
765 ERR("GpImage with no IPicture or bitmap?!\n");
766 return NotImplemented;
767 }
768 }
769
770 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
771 GpBitmap **bitmap)
772 {
773 GpStatus stat;
774 IStream *stream;
775
776 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
777
778 if(!filename || !bitmap)
779 return InvalidParameter;
780
781 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
782
783 if(stat != Ok)
784 return stat;
785
786 stat = GdipCreateBitmapFromStream(stream, bitmap);
787
788 IStream_Release(stream);
789
790 return stat;
791 }
792
793 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
794 VOID *bits, GpBitmap **bitmap)
795 {
796 DWORD height, stride;
797 PixelFormat format;
798
799 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
800
801 height = abs(info->bmiHeader.biHeight);
802 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
803
804 if(info->bmiHeader.biHeight > 0) /* bottom-up */
805 {
806 bits = (BYTE*)bits + (height - 1) * stride;
807 stride = -stride;
808 }
809
810 switch(info->bmiHeader.biBitCount) {
811 case 1:
812 format = PixelFormat1bppIndexed;
813 break;
814 case 4:
815 format = PixelFormat4bppIndexed;
816 break;
817 case 8:
818 format = PixelFormat8bppIndexed;
819 break;
820 case 24:
821 format = PixelFormat24bppRGB;
822 break;
823 default:
824 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
825 *bitmap = NULL;
826 return InvalidParameter;
827 }
828
829 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
830 bits, bitmap);
831
832 }
833
834 /* FIXME: no icm */
835 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
836 GpBitmap **bitmap)
837 {
838 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
839
840 return GdipCreateBitmapFromFile(filename, bitmap);
841 }
842
843 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
844 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
845 {
846 HBITMAP hbm;
847 GpStatus stat = InvalidParameter;
848
849 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
850
851 if(!lpBitmapName || !bitmap)
852 return InvalidParameter;
853
854 /* load DIB */
855 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
856 LR_CREATEDIBSECTION);
857
858 if(hbm){
859 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
860 DeleteObject(hbm);
861 }
862
863 return stat;
864 }
865
866 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
867 HBITMAP* hbmReturn, ARGB background)
868 {
869 GpStatus stat;
870 HBITMAP result, oldbitmap;
871 UINT width, height;
872 HDC hdc;
873 GpGraphics *graphics;
874 BITMAPINFOHEADER bih;
875 void *bits;
876 TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
877
878 if (!bitmap || !hbmReturn) return InvalidParameter;
879
880 GdipGetImageWidth((GpImage*)bitmap, &width);
881 GdipGetImageHeight((GpImage*)bitmap, &height);
882
883 bih.biSize = sizeof(bih);
884 bih.biWidth = width;
885 bih.biHeight = height;
886 bih.biPlanes = 1;
887 bih.biBitCount = 32;
888 bih.biCompression = BI_RGB;
889 bih.biSizeImage = 0;
890 bih.biXPelsPerMeter = 0;
891 bih.biYPelsPerMeter = 0;
892 bih.biClrUsed = 0;
893 bih.biClrImportant = 0;
894
895 hdc = CreateCompatibleDC(NULL);
896 if (!hdc) return GenericError;
897
898 result = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, &bits,
899 NULL, 0);
900
901 if (result)
902 {
903 oldbitmap = SelectObject(hdc, result);
904
905 stat = GdipCreateFromHDC(hdc, &graphics);
906 if (stat == Ok)
907 {
908 stat = GdipGraphicsClear(graphics, background);
909
910 if (stat == Ok)
911 stat = GdipDrawImage(graphics, (GpImage*)bitmap, 0, 0);
912
913 GdipDeleteGraphics(graphics);
914 }
915
916 SelectObject(hdc, oldbitmap);
917 }
918 else
919 stat = GenericError;
920
921 DeleteDC(hdc);
922
923 if (stat != Ok && result)
924 {
925 DeleteObject(result);
926 result = NULL;
927 }
928
929 *hbmReturn = result;
930
931 return stat;
932 }
933
934 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
935 GpMetafile* metafile, BOOL* succ, EmfType emfType,
936 const WCHAR* description, GpMetafile** out_metafile)
937 {
938 static int calls;
939
940 if(!ref || !metafile || !out_metafile)
941 return InvalidParameter;
942
943 *succ = FALSE;
944 *out_metafile = NULL;
945
946 if(!(calls++))
947 FIXME("not implemented\n");
948
949 return NotImplemented;
950 }
951
952 /* FIXME: this should create a bitmap in the given size with the attributes
953 * (resolution etc.) of the graphics object */
954 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
955 GpGraphics* target, GpBitmap** bitmap)
956 {
957 static int calls;
958 GpStatus ret;
959
960 if(!target || !bitmap)
961 return InvalidParameter;
962
963 if(!(calls++))
964 FIXME("hacked stub\n");
965
966 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
967 NULL, bitmap);
968
969 return ret;
970 }
971
972 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
973 {
974 GpStatus stat;
975 ICONINFO iinfo;
976 BITMAP bm;
977 int ret;
978 UINT width, height;
979 GpRect rect;
980 BitmapData lockeddata;
981 HDC screendc;
982 BOOL has_alpha;
983 int x, y;
984 BYTE *bits;
985 BITMAPINFOHEADER bih;
986 DWORD *src;
987 BYTE *dst_row;
988 DWORD *dst;
989
990 TRACE("%p, %p\n", hicon, bitmap);
991
992 if(!bitmap || !GetIconInfo(hicon, &iinfo))
993 return InvalidParameter;
994
995 /* get the size of the icon */
996 ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
997 if (ret == 0) {
998 DeleteObject(iinfo.hbmColor);
999 DeleteObject(iinfo.hbmMask);
1000 return GenericError;
1001 }
1002
1003 width = bm.bmWidth;
1004
1005 if (iinfo.hbmColor)
1006 height = abs(bm.bmHeight);
1007 else /* combined bitmap + mask */
1008 height = abs(bm.bmHeight) / 2;
1009
1010 bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
1011 if (!bits) {
1012 DeleteObject(iinfo.hbmColor);
1013 DeleteObject(iinfo.hbmMask);
1014 return OutOfMemory;
1015 }
1016
1017 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
1018 if (stat != Ok) {
1019 DeleteObject(iinfo.hbmColor);
1020 DeleteObject(iinfo.hbmMask);
1021 HeapFree(GetProcessHeap(), 0, bits);
1022 return stat;
1023 }
1024
1025 rect.X = 0;
1026 rect.Y = 0;
1027 rect.Width = width;
1028 rect.Height = height;
1029
1030 stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
1031 if (stat != Ok) {
1032 DeleteObject(iinfo.hbmColor);
1033 DeleteObject(iinfo.hbmMask);
1034 HeapFree(GetProcessHeap(), 0, bits);
1035 GdipDisposeImage((GpImage*)*bitmap);
1036 return stat;
1037 }
1038
1039 bih.biSize = sizeof(bih);
1040 bih.biWidth = width;
1041 bih.biHeight = -height;
1042 bih.biPlanes = 1;
1043 bih.biBitCount = 32;
1044 bih.biCompression = BI_RGB;
1045 bih.biSizeImage = 0;
1046 bih.biXPelsPerMeter = 0;
1047 bih.biYPelsPerMeter = 0;
1048 bih.biClrUsed = 0;
1049 bih.biClrImportant = 0;
1050
1051 screendc = GetDC(0);
1052 if (iinfo.hbmColor)
1053 {
1054 GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1055
1056 if (bm.bmBitsPixel == 32)
1057 {
1058 has_alpha = FALSE;
1059
1060 /* If any pixel has a non-zero alpha, ignore hbmMask */
1061 src = (DWORD*)bits;
1062 for (x=0; x<width && !has_alpha; x++)
1063 for (y=0; y<height && !has_alpha; y++)
1064 if ((*src++ & 0xff000000) != 0)
1065 has_alpha = TRUE;
1066 }
1067 else has_alpha = FALSE;
1068 }
1069 else
1070 {
1071 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1072 has_alpha = FALSE;
1073 }
1074
1075 /* copy the image data to the Bitmap */
1076 src = (DWORD*)bits;
1077 dst_row = lockeddata.Scan0;
1078 for (y=0; y<height; y++)
1079 {
1080 memcpy(dst_row, src, width*4);
1081 src += width;
1082 dst_row += lockeddata.Stride;
1083 }
1084
1085 if (!has_alpha)
1086 {
1087 if (iinfo.hbmMask)
1088 {
1089 /* read alpha data from the mask */
1090 if (iinfo.hbmColor)
1091 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1092 else
1093 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1094
1095 src = (DWORD*)bits;
1096 dst_row = lockeddata.Scan0;
1097 for (y=0; y<height; y++)
1098 {
1099 dst = (DWORD*)dst_row;
1100 for (x=0; x<height; x++)
1101 {
1102 DWORD src_value = *src++;
1103 if (src_value)
1104 *dst++ = 0;
1105 else
1106 *dst++ |= 0xff000000;
1107 }
1108 dst_row += lockeddata.Stride;
1109 }
1110 }
1111 else
1112 {
1113 /* set constant alpha of 255 */
1114 dst_row = bits;
1115 for (y=0; y<height; y++)
1116 {
1117 dst = (DWORD*)dst_row;
1118 for (x=0; x<height; x++)
1119 *dst++ |= 0xff000000;
1120 dst_row += lockeddata.Stride;
1121 }
1122 }
1123 }
1124
1125 ReleaseDC(0, screendc);
1126
1127 DeleteObject(iinfo.hbmColor);
1128 DeleteObject(iinfo.hbmMask);
1129
1130 GdipBitmapUnlockBits(*bitmap, &lockeddata);
1131
1132 HeapFree(GetProcessHeap(), 0, bits);
1133
1134 return Ok;
1135 }
1136
1137 static void generate_halftone_palette(ARGB *entries, UINT count)
1138 {
1139 static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1140 UINT i;
1141
1142 for (i=0; i<8 && i<count; i++)
1143 {
1144 entries[i] = 0xff000000;
1145 if (i&1) entries[i] |= 0x800000;
1146 if (i&2) entries[i] |= 0x8000;
1147 if (i&4) entries[i] |= 0x80;
1148 }
1149
1150 if (8 < count)
1151 entries[i] = 0xffc0c0c0;
1152
1153 for (i=9; i<16 && i<count; i++)
1154 {
1155 entries[i] = 0xff000000;
1156 if (i&1) entries[i] |= 0xff0000;
1157 if (i&2) entries[i] |= 0xff00;
1158 if (i&4) entries[i] |= 0xff;
1159 }
1160
1161 for (i=16; i<40 && i<count; i++)
1162 {
1163 entries[i] = 0;
1164 }
1165
1166 for (i=40; i<256 && i<count; i++)
1167 {
1168 entries[i] = 0xff000000;
1169 entries[i] |= halftone_values[(i-40)%6];
1170 entries[i] |= halftone_values[((i-40)/6)%6] << 8;
1171 entries[i] |= halftone_values[((i-40)/36)%6] << 16;
1172 }
1173 }
1174
1175 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1176 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1177 {
1178 BITMAPINFOHEADER bmih;
1179 HBITMAP hbitmap;
1180 INT row_size, dib_stride;
1181 HDC hdc;
1182 BYTE *bits;
1183 int i;
1184
1185 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
1186
1187 if (!bitmap) return InvalidParameter;
1188
1189 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1190 *bitmap = NULL;
1191 return InvalidParameter;
1192 }
1193
1194 if(scan0 && !stride)
1195 return InvalidParameter;
1196
1197 row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1198 dib_stride = (row_size + 3) & ~3;
1199
1200 if(stride == 0)
1201 stride = dib_stride;
1202
1203 bmih.biSize = sizeof(BITMAPINFOHEADER);
1204 bmih.biWidth = width;
1205 bmih.biHeight = -height;
1206 bmih.biPlanes = 1;
1207 /* FIXME: use the rest of the data from format */
1208 bmih.biBitCount = PIXELFORMATBPP(format);
1209 bmih.biCompression = BI_RGB;
1210 bmih.biSizeImage = 0;
1211 bmih.biXPelsPerMeter = 0;
1212 bmih.biYPelsPerMeter = 0;
1213 bmih.biClrUsed = 0;
1214 bmih.biClrImportant = 0;
1215
1216 hdc = CreateCompatibleDC(NULL);
1217 if (!hdc) return GenericError;
1218
1219 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits,
1220 NULL, 0);
1221
1222 DeleteDC(hdc);
1223
1224 if (!hbitmap) return GenericError;
1225
1226 /* copy bits to the dib if necessary */
1227 /* FIXME: should reference the bits instead of copying them */
1228 if (scan0)
1229 for (i=0; i<height; i++)
1230 memcpy(bits+i*dib_stride, scan0+i*stride, row_size);
1231
1232 *bitmap = GdipAlloc(sizeof(GpBitmap));
1233 if(!*bitmap)
1234 {
1235 DeleteObject(hbitmap);
1236 return OutOfMemory;
1237 }
1238
1239 (*bitmap)->image.type = ImageTypeBitmap;
1240 memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1241 (*bitmap)->image.flags = ImageFlagsNone;
1242 (*bitmap)->image.palette_flags = 0;
1243 (*bitmap)->image.palette_count = 0;
1244 (*bitmap)->image.palette_size = 0;
1245 (*bitmap)->image.palette_entries = NULL;
1246 (*bitmap)->width = width;
1247 (*bitmap)->height = height;
1248 (*bitmap)->format = format;
1249 (*bitmap)->image.picture = NULL;
1250 (*bitmap)->hbitmap = hbitmap;
1251 (*bitmap)->hdc = NULL;
1252 (*bitmap)->bits = bits;
1253 (*bitmap)->stride = dib_stride;
1254
1255 if (format == PixelFormat1bppIndexed ||
1256 format == PixelFormat4bppIndexed ||
1257 format == PixelFormat8bppIndexed)
1258 {
1259 (*bitmap)->image.palette_size = (*bitmap)->image.palette_count = 1 << PIXELFORMATBPP(format);
1260 (*bitmap)->image.palette_entries = GdipAlloc(sizeof(ARGB) * ((*bitmap)->image.palette_size));
1261
1262 if (!(*bitmap)->image.palette_entries)
1263 {
1264 GdipDisposeImage(&(*bitmap)->image);
1265 *bitmap = NULL;
1266 return OutOfMemory;
1267 }
1268
1269 if (format == PixelFormat1bppIndexed)
1270 {
1271 (*bitmap)->image.palette_flags = PaletteFlagsGrayScale;
1272 (*bitmap)->image.palette_entries[0] = 0xff000000;
1273 (*bitmap)->image.palette_entries[1] = 0xffffffff;
1274 }
1275 else
1276 {
1277 if (format == PixelFormat8bppIndexed)
1278 (*bitmap)->image.palette_flags = PaletteFlagsHalftone;
1279
1280 generate_halftone_palette((*bitmap)->image.palette_entries,
1281 (*bitmap)->image.palette_count);
1282 }
1283 }
1284
1285 return Ok;
1286 }
1287
1288 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1289 GpBitmap **bitmap)
1290 {
1291 GpStatus stat;
1292
1293 TRACE("%p %p\n", stream, bitmap);
1294
1295 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1296
1297 if(stat != Ok)
1298 return stat;
1299
1300 if((*bitmap)->image.type != ImageTypeBitmap){
1301 GdipDisposeImage(&(*bitmap)->image);
1302 *bitmap = NULL;
1303 return GenericError; /* FIXME: what error to return? */
1304 }
1305
1306 return Ok;
1307 }
1308
1309 /* FIXME: no icm */
1310 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1311 GpBitmap **bitmap)
1312 {
1313 TRACE("%p %p\n", stream, bitmap);
1314
1315 return GdipCreateBitmapFromStream(stream, bitmap);
1316 }
1317
1318 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1319 GpCachedBitmap **cachedbmp)
1320 {
1321 GpStatus stat;
1322
1323 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1324
1325 if(!bitmap || !graphics || !cachedbmp)
1326 return InvalidParameter;
1327
1328 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
1329 if(!*cachedbmp)
1330 return OutOfMemory;
1331
1332 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1333 if(stat != Ok){
1334 GdipFree(*cachedbmp);
1335 return stat;
1336 }
1337
1338 return Ok;
1339 }
1340
1341 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1342 {
1343 FIXME("(%p, %p)\n", bitmap, hicon);
1344
1345 return NotImplemented;
1346 }
1347
1348 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
1349 {
1350 TRACE("%p\n", cachedbmp);
1351
1352 if(!cachedbmp)
1353 return InvalidParameter;
1354
1355 GdipDisposeImage(cachedbmp->image);
1356 GdipFree(cachedbmp);
1357
1358 return Ok;
1359 }
1360
1361 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
1362 GpCachedBitmap *cachedbmp, INT x, INT y)
1363 {
1364 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
1365
1366 if(!graphics || !cachedbmp)
1367 return InvalidParameter;
1368
1369 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
1370 }
1371
1372 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
1373 LPBYTE pData16, INT iMapMode, INT eFlags)
1374 {
1375 FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
1376 return NotImplemented;
1377 }
1378
1379 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
1380 {
1381 TRACE("%p\n", image);
1382
1383 if(!image)
1384 return InvalidParameter;
1385
1386 if (image->picture)
1387 IPicture_Release(image->picture);
1388 if (image->type == ImageTypeBitmap)
1389 {
1390 GdipFree(((GpBitmap*)image)->bitmapbits);
1391 DeleteDC(((GpBitmap*)image)->hdc);
1392 }
1393 GdipFree(image->palette_entries);
1394 GdipFree(image);
1395
1396 return Ok;
1397 }
1398
1399 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
1400 {
1401 if(!image || !item)
1402 return InvalidParameter;
1403
1404 return NotImplemented;
1405 }
1406
1407 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
1408 GpUnit *srcUnit)
1409 {
1410 TRACE("%p %p %p\n", image, srcRect, srcUnit);
1411
1412 if(!image || !srcRect || !srcUnit)
1413 return InvalidParameter;
1414 if(image->type == ImageTypeMetafile){
1415 *srcRect = ((GpMetafile*)image)->bounds;
1416 *srcUnit = ((GpMetafile*)image)->unit;
1417 }
1418 else if(image->type == ImageTypeBitmap){
1419 srcRect->X = srcRect->Y = 0.0;
1420 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
1421 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
1422 *srcUnit = UnitPixel;
1423 }
1424 else{
1425 srcRect->X = srcRect->Y = 0.0;
1426 srcRect->Width = ipicture_pixel_width(image->picture);
1427 srcRect->Height = ipicture_pixel_height(image->picture);
1428 *srcUnit = UnitPixel;
1429 }
1430
1431 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
1432 srcRect->Width, srcRect->Height, *srcUnit);
1433
1434 return Ok;
1435 }
1436
1437 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
1438 REAL *height)
1439 {
1440 TRACE("%p %p %p\n", image, width, height);
1441
1442 if(!image || !height || !width)
1443 return InvalidParameter;
1444
1445 if(image->type == ImageTypeMetafile){
1446 HDC hdc = GetDC(0);
1447
1448 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1449 ((GpMetafile*)image)->bounds.Height;
1450
1451 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1452 ((GpMetafile*)image)->bounds.Width;
1453
1454 ReleaseDC(0, hdc);
1455 }
1456
1457 else if(image->type == ImageTypeBitmap){
1458 *height = ((GpBitmap*)image)->height;
1459 *width = ((GpBitmap*)image)->width;
1460 }
1461 else{
1462 *height = ipicture_pixel_height(image->picture);
1463 *width = ipicture_pixel_width(image->picture);
1464 }
1465
1466 TRACE("returning (%f, %f)\n", *height, *width);
1467 return Ok;
1468 }
1469
1470 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
1471 GpGraphics **graphics)
1472 {
1473 HDC hdc;
1474
1475 TRACE("%p %p\n", image, graphics);
1476
1477 if(!image || !graphics)
1478 return InvalidParameter;
1479
1480 if(image->type != ImageTypeBitmap){
1481 FIXME("not implemented for image type %d\n", image->type);
1482 return NotImplemented;
1483 }
1484
1485 hdc = ((GpBitmap*)image)->hdc;
1486
1487 if(!hdc){
1488 hdc = CreateCompatibleDC(0);
1489 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
1490 ((GpBitmap*)image)->hdc = hdc;
1491 }
1492
1493 return GdipCreateFromHDC(hdc, graphics);
1494 }
1495
1496 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
1497 {
1498 TRACE("%p %p\n", image, height);
1499
1500 if(!image || !height)
1501 return InvalidParameter;
1502
1503 if(image->type == ImageTypeMetafile){
1504 HDC hdc = GetDC(0);
1505
1506 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1507 ((GpMetafile*)image)->bounds.Height);
1508
1509 ReleaseDC(0, hdc);
1510 }
1511 else if(image->type == ImageTypeBitmap)
1512 *height = ((GpBitmap*)image)->height;
1513 else
1514 *height = ipicture_pixel_height(image->picture);
1515
1516 TRACE("returning %d\n", *height);
1517
1518 return Ok;
1519 }
1520
1521 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
1522 {
1523 static int calls;
1524
1525 if(!image || !res)
1526 return InvalidParameter;
1527
1528 if(!(calls++))
1529 FIXME("not implemented\n");
1530
1531 return NotImplemented;
1532 }
1533
1534 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
1535 {
1536 TRACE("%p %p\n", image, size);
1537
1538 if(!image || !size)
1539 return InvalidParameter;
1540
1541 if (image->palette_count == 0)
1542 *size = sizeof(ColorPalette);
1543 else
1544 *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette_count;
1545
1546 TRACE("<-- %u\n", *size);
1547
1548 return Ok;
1549 }
1550
1551 /* FIXME: test this function for non-bitmap types */
1552 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
1553 {
1554 TRACE("%p %p\n", image, format);
1555
1556 if(!image || !format)
1557 return InvalidParameter;
1558
1559 if(image->type != ImageTypeBitmap)
1560 *format = PixelFormat24bppRGB;
1561 else
1562 *format = ((GpBitmap*) image)->format;
1563
1564 return Ok;
1565 }
1566
1567 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
1568 {
1569 if(!image || !format)
1570 return InvalidParameter;
1571
1572 memcpy(format, &image->format, sizeof(GUID));
1573
1574 return Ok;
1575 }
1576
1577 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
1578 {
1579 TRACE("%p %p\n", image, type);
1580
1581 if(!image || !type)
1582 return InvalidParameter;
1583
1584 *type = image->type;
1585
1586 return Ok;
1587 }
1588
1589 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
1590 {
1591 static int calls;
1592
1593 if(!image || !res)
1594 return InvalidParameter;
1595
1596 if(!(calls++))
1597 FIXME("not implemented\n");
1598
1599 return NotImplemented;
1600 }
1601
1602 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
1603 {
1604 TRACE("%p %p\n", image, width);
1605
1606 if(!image || !width)
1607 return InvalidParameter;
1608
1609 if(image->type == ImageTypeMetafile){
1610 HDC hdc = GetDC(0);
1611
1612 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1613 ((GpMetafile*)image)->bounds.Width);
1614
1615 ReleaseDC(0, hdc);
1616 }
1617 else if(image->type == ImageTypeBitmap)
1618 *width = ((GpBitmap*)image)->width;
1619 else
1620 *width = ipicture_pixel_width(image->picture);
1621
1622 TRACE("returning %d\n", *width);
1623
1624 return Ok;
1625 }
1626
1627 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
1628 MetafileHeader * header)
1629 {
1630 static int calls;
1631
1632 if(!metafile || !header)
1633 return InvalidParameter;
1634
1635 if(!(calls++))
1636 FIXME("not implemented\n");
1637
1638 return Ok;
1639 }
1640
1641 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
1642 UINT num, PropertyItem* items)
1643 {
1644 static int calls;
1645
1646 if(!(calls++))
1647 FIXME("not implemented\n");
1648
1649 return InvalidParameter;
1650 }
1651
1652 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
1653 {
1654 static int calls;
1655
1656 if(!(calls++))
1657 FIXME("not implemented\n");
1658
1659 return InvalidParameter;
1660 }
1661
1662 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
1663 {
1664 static int calls;
1665
1666 if(!(calls++))
1667 FIXME("not implemented\n");
1668
1669 return InvalidParameter;
1670 }
1671
1672 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
1673 PropertyItem* buffer)
1674 {
1675 static int calls;
1676
1677 if(!(calls++))
1678 FIXME("not implemented\n");
1679
1680 return InvalidParameter;
1681 }
1682
1683 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
1684 UINT* size)
1685 {
1686 static int calls;
1687
1688 TRACE("%p %x %p\n", image, pid, size);
1689
1690 if(!size || !image)
1691 return InvalidParameter;
1692
1693 if(!(calls++))
1694 FIXME("not implemented\n");
1695
1696 return NotImplemented;
1697 }
1698
1699 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
1700 {
1701 static int calls;
1702
1703 if(!(calls++))
1704 FIXME("not implemented\n");
1705
1706 return InvalidParameter;
1707 }
1708
1709 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
1710 GDIPCONST GUID* dimensionID, UINT* count)
1711 {
1712 static int calls;
1713
1714 if(!image || !dimensionID || !count)
1715 return InvalidParameter;
1716
1717 if(!(calls++))
1718 FIXME("not implemented\n");
1719
1720 return NotImplemented;
1721 }
1722
1723 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
1724 UINT* count)
1725 {
1726 if(!image || !count)
1727 return InvalidParameter;
1728
1729 *count = 1;
1730
1731 FIXME("stub\n");
1732
1733 return Ok;
1734 }
1735
1736 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
1737 GUID* dimensionIDs, UINT count)
1738 {
1739 static int calls;
1740
1741 if(!image || !dimensionIDs)
1742 return InvalidParameter;
1743
1744 if(!(calls++))
1745 FIXME("not implemented\n");
1746
1747 return Ok;
1748 }
1749
1750 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
1751 GDIPCONST GUID* dimensionID, UINT frameidx)
1752 {
1753 static int calls;
1754
1755 if(!image || !dimensionID)
1756 return InvalidParameter;
1757
1758 if(!(calls++))
1759 FIXME("not implemented\n");
1760
1761 return Ok;
1762 }
1763
1764 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
1765 GpImage **image)
1766 {
1767 GpStatus stat;
1768 IStream *stream;
1769
1770 TRACE("(%s) %p\n", debugstr_w(filename), image);
1771
1772 if (!filename || !image)
1773 return InvalidParameter;
1774
1775 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1776
1777 if (stat != Ok)
1778 return stat;
1779
1780 stat = GdipLoadImageFromStream(stream, image);
1781
1782 IStream_Release(stream);
1783
1784 return stat;
1785 }
1786
1787 /* FIXME: no icm handling */
1788 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1789 {
1790 TRACE("(%s) %p\n", debugstr_w(filename), image);
1791
1792 return GdipLoadImageFromFile(filename, image);
1793 }
1794
1795 static const WICPixelFormatGUID *wic_pixel_formats[] = {
1796 &GUID_WICPixelFormat16bppBGR555,
1797 &GUID_WICPixelFormat24bppBGR,
1798 &GUID_WICPixelFormat32bppBGR,
1799 &GUID_WICPixelFormat32bppBGRA,
1800 &GUID_WICPixelFormat32bppPBGRA,
1801 NULL
1802 };
1803
1804 static const PixelFormat wic_gdip_formats[] = {
1805 PixelFormat16bppRGB555,
1806 PixelFormat24bppRGB,
1807 PixelFormat32bppRGB,
1808 PixelFormat32bppARGB,
1809 PixelFormat32bppPARGB,
1810 };
1811
1812 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, GpImage **image)
1813 {
1814 GpStatus status=Ok;
1815 GpBitmap *bitmap;
1816 HRESULT hr;
1817 IWICBitmapDecoder *decoder;
1818 IWICBitmapFrameDecode *frame;
1819 IWICBitmapSource *source=NULL;
1820 WICPixelFormatGUID wic_format;
1821 PixelFormat gdip_format=0;
1822 int i;
1823 UINT width, height;
1824 BitmapData lockeddata;
1825 WICRect wrc;
1826 HRESULT initresult;
1827
1828 initresult = CoInitialize(NULL);
1829
1830 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
1831 &IID_IWICBitmapDecoder, (void**)&decoder);
1832 if (FAILED(hr)) goto end;
1833
1834 hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1835 if (SUCCEEDED(hr))
1836 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1837
1838 if (SUCCEEDED(hr)) /* got frame */
1839 {
1840 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
1841
1842 if (SUCCEEDED(hr))
1843 {
1844 for (i=0; wic_pixel_formats[i]; i++)
1845 {
1846 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
1847 {
1848 source = (IWICBitmapSource*)frame;
1849 IWICBitmapSource_AddRef(source);
1850 gdip_format = wic_gdip_formats[i];
1851 break;
1852 }
1853 }
1854 if (!source)
1855 {
1856 /* unknown format; fall back on 32bppARGB */
1857 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
1858 gdip_format = PixelFormat32bppARGB;
1859 }
1860 }
1861
1862 if (SUCCEEDED(hr)) /* got source */
1863 {
1864 hr = IWICBitmapSource_GetSize(source, &width, &height);
1865
1866 if (SUCCEEDED(hr))
1867 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
1868 NULL, &bitmap);
1869
1870 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
1871 {
1872 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
1873 gdip_format, &lockeddata);
1874 if (status == Ok) /* locked bitmap */
1875 {
1876 wrc.X = 0;
1877 wrc.Width = width;
1878 wrc.Height = 1;
1879 for (i=0; i<height; i++)
1880 {
1881 wrc.Y = i;
1882 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
1883 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
1884 if (FAILED(hr)) break;
1885 }
1886
1887 GdipBitmapUnlockBits(bitmap, &lockeddata);
1888 }
1889
1890 if (SUCCEEDED(hr) && status == Ok)
1891 *image = (GpImage*)bitmap;
1892 else
1893 {
1894 *image = NULL;
1895 GdipDisposeImage((GpImage*)bitmap);
1896 }
1897 }
1898
1899 IWICBitmapSource_Release(source);
1900 }
1901
1902 IWICBitmapFrameDecode_Release(frame);
1903 }
1904
1905 IWICBitmapDecoder_Release(decoder);
1906
1907 end:
1908 if (SUCCEEDED(initresult)) CoUninitialize();
1909
1910 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
1911
1912 return status;
1913 }
1914
1915 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, GpImage **image)
1916 {
1917 return decode_image_wic(stream, &CLSID_WICIcoDecoder, image);
1918 }
1919
1920 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, GpImage **image)
1921 {
1922 GpStatus status;
1923 GpBitmap* bitmap;
1924
1925 status = decode_image_wic(stream, &CLSID_WICBmpDecoder, image);
1926
1927 bitmap = (GpBitmap*)*image;
1928
1929 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
1930 {
1931 /* WIC supports bmp files with alpha, but gdiplus does not */
1932 bitmap->format = PixelFormat32bppRGB;
1933 }
1934
1935 return status;
1936 }
1937
1938 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, GpImage **image)
1939 {
1940 return decode_image_wic(stream, &CLSID_WICJpegDecoder, image);
1941 }
1942
1943 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, GpImage **image)
1944 {
1945 return decode_image_wic(stream, &CLSID_WICPngDecoder, image);
1946 }
1947
1948 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, GpImage **image)
1949 {
1950 return decode_image_wic(stream, &CLSID_WICGifDecoder, image);
1951 }
1952
1953 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, GpImage **image)
1954 {
1955 IPicture *pic;
1956
1957 TRACE("%p %p\n", stream, image);
1958
1959 if(!stream || !image)
1960 return InvalidParameter;
1961
1962 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1963 (LPVOID*) &pic) != S_OK){
1964 TRACE("Could not load picture\n");
1965 return GenericError;
1966 }
1967
1968 /* FIXME: missing initialization code */
1969 *image = GdipAlloc(sizeof(GpMetafile));
1970 if(!*image) return OutOfMemory;
1971 (*image)->type = ImageTypeMetafile;
1972 (*image)->picture = pic;
1973 (*image)->flags = ImageFlagsNone;
1974 (*image)->palette_flags = 0;
1975 (*image)->palette_count = 0;
1976 (*image)->palette_size = 0;
1977 (*image)->palette_entries = NULL;
1978
1979 return Ok;
1980 }
1981
1982 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
1983 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
1984
1985 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, GpImage** image);
1986
1987 typedef struct image_codec {
1988 ImageCodecInfo info;
1989 encode_image_func encode_func;
1990 decode_image_func decode_func;
1991 } image_codec;
1992
1993 typedef enum {
1994 BMP,
1995 JPEG,
1996 GIF,
1997 EMF,
1998 WMF,
1999 PNG,
2000 ICO,
2001 NUM_CODECS
2002 } ImageFormat;
2003
2004 static const struct image_codec codecs[NUM_CODECS];
2005
2006 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
2007 {
2008 BYTE signature[8];
2009 LARGE_INTEGER seek;
2010 HRESULT hr;
2011 UINT bytesread;
2012 int i, j;
2013
2014 /* seek to the start of the stream */
2015 seek.QuadPart = 0;
2016 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
2017 if (FAILED(hr)) return hresult_to_status(hr);
2018
2019 /* read the first 8 bytes */
2020 /* FIXME: This assumes all codecs have one signature <= 8 bytes in length */
2021 hr = IStream_Read(stream, signature, 8, &bytesread);
2022 if (FAILED(hr)) return hresult_to_status(hr);
2023 if (hr == S_FALSE || bytesread == 0) return GenericError;
2024
2025 for (i = 0; i < NUM_CODECS; i++) {
2026 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
2027 bytesread >= codecs[i].info.SigSize)
2028 {
2029 for (j=0; j<codecs[i].info.SigSize; j++)
2030 if ((signature[j] & codecs[i].info.SigMask[j]) != codecs[i].info.SigPattern[j])
2031 break;
2032 if (j == codecs[i].info.SigSize)
2033 {
2034 *result = &codecs[i];
2035 return Ok;
2036 }
2037 }
2038 }
2039
2040 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
2041 signature[0],signature[1],signature[2],signature[3],
2042 signature[4],signature[5],signature[6],signature[7]);
2043
2044 return GenericError;
2045 }
2046
2047 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
2048 {
2049 GpStatus stat;
2050 LARGE_INTEGER seek;
2051 HRESULT hr;
2052 const struct image_codec *codec=NULL;
2053
2054 /* choose an appropriate image decoder */
2055 stat = get_decoder_info(stream, &codec);
2056 if (stat != Ok) return stat;
2057
2058 /* seek to the start of the stream */
2059 seek.QuadPart = 0;
2060 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
2061 if (FAILED(hr)) return hresult_to_status(hr);
2062
2063 /* call on the image decoder to do the real work */
2064 stat = codec->decode_func(stream, &codec->info.Clsid, image);
2065
2066 /* take note of the original data format */
2067 if (stat == Ok)
2068 {
2069 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
2070 }
2071
2072 return stat;
2073 }
2074
2075 /* FIXME: no ICM */
2076 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
2077 {
2078 TRACE("%p %p\n", stream, image);
2079
2080 return GdipLoadImageFromStream(stream, image);
2081 }
2082
2083 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
2084 {
2085 static int calls;
2086
2087 if(!image)
2088 return InvalidParameter;
2089
2090 if(!(calls++))
2091 FIXME("not implemented\n");
2092
2093 return NotImplemented;
2094 }
2095
2096 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
2097 {
2098 static int calls;
2099
2100 if(!(calls++))
2101 FIXME("not implemented\n");
2102
2103 return NotImplemented;
2104 }
2105
2106 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
2107 GDIPCONST CLSID *clsidEncoder,
2108 GDIPCONST EncoderParameters *encoderParams)
2109 {
2110 GpStatus stat;
2111 IStream *stream;
2112
2113 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
2114
2115 if (!image || !filename|| !clsidEncoder)
2116 return InvalidParameter;
2117
2118 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
2119 if (stat != Ok)
2120 return GenericError;
2121
2122 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
2123
2124 IStream_Release(stream);
2125 return stat;
2126 }
2127
2128 /*************************************************************************
2129 * Encoding functions -
2130 * These functions encode an image in different image file formats.
2131 */
2132 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
2133 #define BITMAP_FORMAT_JPEG 0xd8ff
2134 #define BITMAP_FORMAT_GIF 0x4947
2135 #define BITMAP_FORMAT_PNG 0x5089
2136 #define BITMAP_FORMAT_APM 0xcdd7
2137
2138 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
2139 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2140 {
2141 GpStatus stat;
2142 GpBitmap *bitmap;
2143 IWICBitmapEncoder *encoder;
2144 IWICBitmapFrameEncode *frameencode;
2145 IPropertyBag2 *encoderoptions;
2146 HRESULT hr;
2147 UINT width, height;
2148 PixelFormat gdipformat=0;
2149 WICPixelFormatGUID wicformat;
2150 GpRect rc;
2151 BitmapData lockeddata;
2152 HRESULT initresult;
2153 UINT i;
2154
2155 if (image->type != ImageTypeBitmap)
2156 return GenericError;
2157
2158 bitmap = (GpBitmap*)image;
2159
2160 GdipGetImageWidth(image, &width);
2161 GdipGetImageHeight(image, &height);
2162
2163 rc.X = 0;
2164 rc.Y = 0;
2165 rc.Width = width;
2166 rc.Height = height;
2167
2168 initresult = CoInitialize(NULL);
2169
2170 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2171 &IID_IWICBitmapEncoder, (void**)&encoder);
2172 if (FAILED(hr))
2173 {
2174 if (SUCCEEDED(initresult)) CoUninitialize();
2175 return hresult_to_status(hr);
2176 }
2177
2178 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
2179
2180 if (SUCCEEDED(hr))
2181 {
2182 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
2183 }
2184
2185 if (SUCCEEDED(hr)) /* created frame */
2186 {
2187 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
2188
2189 if (SUCCEEDED(hr))
2190 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
2191
2192 if (SUCCEEDED(hr))
2193 /* FIXME: use the resolution from the image */
2194 hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
2195
2196 if (SUCCEEDED(hr))
2197 {
2198 for (i=0; wic_pixel_formats[i]; i++)
2199 {
2200 if (wic_gdip_formats[i] == bitmap->format)
2201 break;
2202 }
2203 if (wic_pixel_formats[i])
2204 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
2205 else
2206 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
2207
2208 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
2209
2210 for (i=0; wic_pixel_formats[i]; i++)
2211 {
2212 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
2213 break;
2214 }
2215 if (wic_pixel_formats[i])
2216 gdipformat = wic_gdip_formats[i];
2217 else
2218 {
2219 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
2220 hr = E_FAIL;
2221 }
2222 }
2223
2224 if (SUCCEEDED(hr))
2225 {
2226 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
2227 &lockeddata);
2228
2229 if (stat == Ok)
2230 {
2231 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
2232 BYTE *row;
2233
2234 /* write one row at a time in case stride is negative */
2235 row = lockeddata.Scan0;
2236 for (i=0; i<lockeddata.Height; i++)
2237 {
2238 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
2239 if (FAILED(hr)) break;
2240 row += lockeddata.Stride;
2241 }
2242
2243 GdipBitmapUnlockBits(bitmap, &lockeddata);
2244 }
2245 else
2246 hr = E_FAIL;
2247 }
2248
2249 if (SUCCEEDED(hr))
2250 hr = IWICBitmapFrameEncode_Commit(frameencode);
2251
2252 IWICBitmapFrameEncode_Release(frameencode);
2253 IPropertyBag2_Release(encoderoptions);
2254 }
2255
2256 if (SUCCEEDED(hr))
2257 hr = IWICBitmapEncoder_Commit(encoder);
2258
2259 IWICBitmapEncoder_Release(encoder);
2260
2261 if (SUCCEEDED(initresult)) CoUninitialize();
2262
2263 return hresult_to_status(hr);
2264 }
2265
2266 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
2267 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2268 {
2269 return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
2270 }
2271
2272 static GpStatus encode_image_png(GpImage *image, IStream* stream,
2273 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2274 {
2275 return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
2276 }
2277
2278 /*****************************************************************************
2279 * GdipSaveImageToStream [GDIPLUS.@]
2280 */
2281 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
2282 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2283 {
2284 GpStatus stat;
2285 encode_image_func encode_image;
2286 int i;
2287
2288 TRACE("%p %p %p %p\n", image, stream, clsid, params);
2289
2290 if(!image || !stream)
2291 return InvalidParameter;
2292
2293 /* select correct encoder */
2294 encode_image = NULL;
2295 for (i = 0; i < NUM_CODECS; i++) {
2296 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
2297 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
2298 encode_image = codecs[i].encode_func;
2299 }
2300 if (encode_image == NULL)
2301 return UnknownImageFormat;
2302
2303 stat = encode_image(image, stream, clsid, params);
2304
2305 return stat;
2306 }
2307
2308 /*****************************************************************************
2309 * GdipGetImagePalette [GDIPLUS.@]
2310 */
2311 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
2312 {
2313 TRACE("(%p,%p,%i)\n", image, palette, size);
2314
2315 if (!image || !palette)
2316 return InvalidParameter;
2317
2318 if (size < (sizeof(UINT)*2+sizeof(ARGB)*image->palette_count))
2319 {
2320 TRACE("<-- InsufficientBuffer\n");
2321 return InsufficientBuffer;
2322 }
2323
2324 palette->Flags = image->palette_flags;
2325 palette->Count = image->palette_count;
2326 memcpy(palette->Entries, image->palette_entries, sizeof(ARGB)*image->palette_count);
2327
2328 return Ok;
2329 }
2330
2331 /*****************************************************************************
2332 * GdipSetImagePalette [GDIPLUS.@]
2333 */
2334 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
2335 GDIPCONST ColorPalette *palette)
2336 {
2337 TRACE("(%p,%p)\n", image, palette);
2338
2339 if(!image || !palette || palette->Count > 256)
2340 return InvalidParameter;
2341
2342 if (palette->Count > image->palette_size)
2343 {
2344 ARGB *new_palette;
2345
2346 new_palette = GdipAlloc(sizeof(ARGB) * palette->Count);
2347 if (!new_palette) return OutOfMemory;
2348
2349 GdipFree(image->palette_entries);
2350 image->palette_entries = new_palette;
2351 image->palette_size = palette->Count;
2352 }
2353
2354 image->palette_flags = palette->Flags;
2355 image->palette_count = palette->Count;
2356 memcpy(image->palette_entries, palette->Entries, sizeof(ARGB)*palette->Count);
2357
2358 return Ok;
2359 }
2360
2361 /*************************************************************************
2362 * Encoders -
2363 * Structures that represent which formats we support for encoding.
2364 */
2365
2366 /* ImageCodecInfo creation routines taken from libgdiplus */
2367 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
2368 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
2369 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
2370 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
2371 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
2372 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
2373
2374 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
2375 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
2376 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
2377 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
2378 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
2379 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
2380
2381 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
2382 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
2383 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
2384 static const WCHAR gif_format[] = {'G','I','F',0};
2385 static const BYTE gif_sig_pattern[4] = "GIF8";
2386 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2387
2388 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
2389 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
2390 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
2391 static const WCHAR emf_format[] = {'E','M','F',0};
2392 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
2393 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2394
2395 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
2396 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
2397 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
2398 static const WCHAR wmf_format[] = {'W','M','F',0};
2399 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
2400 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
2401
2402 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
2403 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
2404 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
2405 static const WCHAR png_format[] = {'P','N','G',0};
2406 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
2407 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2408
2409 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
2410 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
2411 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
2412 static const WCHAR ico_format[] = {'I','C','O',0};
2413 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
2414 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2415
2416 static const struct image_codec codecs[NUM_CODECS] = {
2417 {
2418 { /* BMP */
2419 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2420 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2421 /* CodecName */ bmp_codecname,
2422 /* DllName */ NULL,
2423 /* FormatDescription */ bmp_format,
2424 /* FilenameExtension */ bmp_extension,
2425 /* MimeType */ bmp_mimetype,
2426 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2427 /* Version */ 1,
2428 /* SigCount */ 1,
2429 /* SigSize */ 2,
2430 /* SigPattern */ bmp_sig_pattern,
2431 /* SigMask */ bmp_sig_mask,
2432 },
2433 encode_image_BMP,
2434 decode_image_bmp
2435 },
2436 {
2437 { /* JPEG */
2438 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2439 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2440 /* CodecName */ jpeg_codecname,
2441 /* DllName */ NULL,
2442 /* FormatDescription */ jpeg_format,
2443 /* FilenameExtension */ jpeg_extension,
2444 /* MimeType */ jpeg_mimetype,
2445 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2446 /* Version */ 1,
2447 /* SigCount */ 1,
2448 /* SigSize */ 2,
2449 /* SigPattern */ jpeg_sig_pattern,
2450 /* SigMask */ jpeg_sig_mask,
2451 },
2452 NULL,
2453 decode_image_jpeg
2454 },
2455 {
2456 { /* GIF */
2457 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2458 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2459 /* CodecName */ gif_codecname,
2460 /* DllName */ NULL,
2461 /* FormatDescription */ gif_format,
2462 /* FilenameExtension */ gif_extension,
2463 /* MimeType */ gif_mimetype,
2464 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2465 /* Version */ 1,
2466 /* SigCount */ 1,
2467 /* SigSize */ 4,
2468 /* SigPattern */ gif_sig_pattern,
2469 /* SigMask */ gif_sig_mask,
2470 },
2471 NULL,
2472 decode_image_gif
2473 },
2474 {
2475 { /* EMF */
2476 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2477 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2478 /* CodecName */ emf_codecname,
2479 /* DllName */ NULL,
2480 /* FormatDescription */ emf_format,
2481 /* FilenameExtension */ emf_extension,
2482 /* MimeType */ emf_mimetype,
2483 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2484 /* Version */ 1,
2485 /* SigCount */ 1,
2486 /* SigSize */ 4,
2487 /* SigPattern */ emf_sig_pattern,
2488 /* SigMask */ emf_sig_mask,
2489 },
2490 NULL,
2491 decode_image_olepicture_metafile
2492 },
2493 {
2494 { /* WMF */
2495 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2496 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2497 /* CodecName */ wmf_codecname,
2498 /* DllName */ NULL,
2499 /* FormatDescription */ wmf_format,
2500 /* FilenameExtension */ wmf_extension,
2501 /* MimeType */ wmf_mimetype,
2502 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2503 /* Version */ 1,
2504 /* SigCount */ 1,
2505 /* SigSize */ 2,
2506 /* SigPattern */ wmf_sig_pattern,
2507 /* SigMask */ wmf_sig_mask,
2508 },
2509 NULL,
2510 decode_image_olepicture_metafile
2511 },
2512 {
2513 { /* PNG */
2514 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2515 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2516 /* CodecName */ png_codecname,
2517 /* DllName */ NULL,
2518 /* FormatDescription */ png_format,
2519 /* FilenameExtension */ png_extension,
2520 /* MimeType */ png_mimetype,
2521 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2522 /* Version */ 1,
2523 /* SigCount */ 1,
2524 /* SigSize */ 8,
2525 /* SigPattern */ png_sig_pattern,
2526 /* SigMask */ png_sig_mask,
2527 },
2528 encode_image_png,
2529 decode_image_png
2530 },
2531 {
2532 { /* ICO */
2533 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2534 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2535 /* CodecName */ ico_codecname,
2536 /* DllName */ NULL,
2537 /* FormatDescription */ ico_format,
2538 /* FilenameExtension */ ico_extension,
2539 /* MimeType */ ico_mimetype,
2540 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2541 /* Version */ 1,
2542 /* SigCount */ 1,
2543 /* SigSize */ 4,
2544 /* SigPattern */ ico_sig_pattern,
2545 /* SigMask */ ico_sig_mask,
2546 },
2547 NULL,
2548 decode_image_icon
2549 },
2550 };
2551
2552 /*****************************************************************************
2553 * GdipGetImageDecodersSize [GDIPLUS.@]
2554 */
2555 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
2556 {
2557 int decoder_count=0;
2558 int i;
2559 TRACE("%p %p\n", numDecoders, size);
2560
2561 if (!numDecoders || !size)
2562 return InvalidParameter;
2563
2564 for (i=0; i<NUM_CODECS; i++)
2565 {
2566 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2567 decoder_count++;
2568 }
2569
2570 *numDecoders = decoder_count;
2571 *size = decoder_count * sizeof(ImageCodecInfo);
2572
2573 return Ok;
2574 }
2575
2576 /*****************************************************************************
2577 * GdipGetImageDecoders [GDIPLUS.@]
2578 */
2579 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
2580 {
2581 int i, decoder_count=0;
2582 TRACE("%u %u %p\n", numDecoders, size, decoders);
2583
2584 if (!decoders ||
2585 size != numDecoders * sizeof(ImageCodecInfo))
2586 return GenericError;
2587
2588 for (i=0; i<NUM_CODECS; i++)
2589 {
2590 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2591 {
2592 if (decoder_count == numDecoders) return GenericError;
2593 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2594 decoder_count++;
2595 }
2596 }
2597
2598 if (decoder_count < numDecoders) return GenericError;
2599
2600 return Ok;
2601 }
2602
2603 /*****************************************************************************
2604 * GdipGetImageEncodersSize [GDIPLUS.@]
2605 */
2606 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
2607 {
2608 int encoder_count=0;
2609 int i;
2610 TRACE("%p %p\n", numEncoders, size);
2611
2612 if (!numEncoders || !size)
2613 return InvalidParameter;
2614
2615 for (i=0; i<NUM_CODECS; i++)
2616 {
2617 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2618 encoder_count++;
2619 }
2620
2621 *numEncoders = encoder_count;
2622 *size = encoder_count * sizeof(ImageCodecInfo);
2623
2624 return Ok;
2625 }
2626
2627 /*****************************************************************************
2628 * GdipGetImageEncoders [GDIPLUS.@]
2629 */
2630 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
2631 {
2632 int i, encoder_count=0;
2633 TRACE("%u %u %p\n", numEncoders, size, encoders);
2634
2635 if (!encoders ||
2636 size != numEncoders * sizeof(ImageCodecInfo))
2637 return GenericError;
2638
2639 for (i=0; i<NUM_CODECS; i++)
2640 {
2641 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2642 {
2643 if (encoder_count == numEncoders) return GenericError;
2644 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2645 encoder_count++;
2646 }
2647 }
2648
2649 if (encoder_count < numEncoders) return GenericError;
2650
2651 return Ok;
2652 }
2653
2654 /*****************************************************************************
2655 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
2656 */
2657 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
2658 {
2659 BITMAP bm;
2660 GpStatus retval;
2661 PixelFormat format;
2662 BitmapData lockeddata;
2663 INT y;
2664
2665 TRACE("%p %p %p\n", hbm, hpal, bitmap);
2666
2667 if(!hbm || !bitmap)
2668 return InvalidParameter;
2669
2670 /* TODO: Support for device-dependent bitmaps */
2671 if(hpal){
2672 FIXME("no support for device-dependent bitmaps\n");
2673 return NotImplemented;
2674 }
2675
2676 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
2677 return InvalidParameter;
2678
2679 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
2680 switch(bm.bmBitsPixel) {
2681 case 1:
2682 format = PixelFormat1bppIndexed;
2683 break;
2684 case 4:
2685 format = PixelFormat4bppIndexed;
2686 break;
2687 case 8:
2688 format = PixelFormat8bppIndexed;
2689 break;
2690 case 24:
2691 format = PixelFormat24bppRGB;
2692 break;
2693 case 32:
2694 format = PixelFormat32bppRGB;
2695 break;
2696 case 48:
2697 format = PixelFormat48bppRGB;
2698 break;
2699 default:
2700 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
2701 return InvalidParameter;
2702 }
2703
2704 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
2705 format, NULL, bitmap);
2706
2707 if (retval == Ok)
2708 {
2709 retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
2710 format, &lockeddata);
2711 if (retval == Ok)
2712 {
2713 if (bm.bmBits)
2714 {
2715 for (y=0; y<bm.bmHeight; y++)
2716 {
2717 memcpy((BYTE*)lockeddata.Scan0+lockeddata.Stride*y,
2718 (BYTE*)bm.bmBits+bm.bmWidthBytes*(bm.bmHeight-1-y),
2719 bm.bmWidthBytes);
2720 }
2721 }
2722 else
2723 {
2724 HDC hdc;
2725 HBITMAP oldhbm;
2726 BITMAPINFO *pbmi;
2727 INT src_height, dst_stride;
2728 BYTE *dst_bits;
2729
2730 hdc = CreateCompatibleDC(NULL);
2731 oldhbm = SelectObject(hdc, hbm);
2732
2733 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
2734
2735 if (pbmi)
2736 {
2737 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2738 pbmi->bmiHeader.biBitCount = 0;
2739
2740 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
2741
2742 src_height = abs(pbmi->bmiHeader.biHeight);
2743
2744 if (pbmi->bmiHeader.biHeight > 0)
2745 {
2746 dst_bits = (BYTE*)lockeddata.Scan0+lockeddata.Stride*(src_height-1);
2747 dst_stride = -lockeddata.Stride;
2748 }
2749 else
2750 {
2751 dst_bits = lockeddata.Scan0;
2752 dst_stride = lockeddata.Stride;
2753 }
2754
2755 for (y=0; y<src_height; y++)
2756 {
2757 GetDIBits(hdc, hbm, y, 1, dst_bits+dst_stride*y,
2758 pbmi, DIB_RGB_COLORS);
2759 }
2760
2761 GdipFree(pbmi);
2762 }
2763 else
2764 retval = OutOfMemory;
2765
2766 SelectObject(hdc, oldhbm);
2767 DeleteDC(hdc);
2768 }
2769
2770 GdipBitmapUnlockBits(*bitmap, &lockeddata);
2771 }
2772 }
2773
2774 return retval;
2775 }
2776
2777 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
2778 {
2779 FIXME("(%p): stub\n", effect);
2780 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
2781 * in Windows's gdiplus */
2782 return NotImplemented;
2783 }
2784
2785 /*****************************************************************************
2786 * GdipSetEffectParameters [GDIPLUS.@]
2787 */
2788 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
2789 const VOID *params, const UINT size)
2790 {
2791 static int calls;
2792
2793 if(!(calls++))
2794 FIXME("not implemented\n");
2795
2796 return NotImplemented;
2797 }
2798
2799 /*****************************************************************************
2800 * GdipGetImageFlags [GDIPLUS.@]
2801 */
2802 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
2803 {
2804 TRACE("%p %p\n", image, flags);
2805
2806 if(!image || !flags)
2807 return InvalidParameter;
2808
2809 *flags = image->flags;
2810
2811 return Ok;
2812 }
2813
2814 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
2815 {
2816 TRACE("(%d, %p)\n", control, param);
2817
2818 switch(control){
2819 case TestControlForceBilinear:
2820 if(param)
2821 FIXME("TestControlForceBilinear not handled\n");
2822 break;
2823 case TestControlNoICM:
2824 if(param)
2825 FIXME("TestControlNoICM not handled\n");
2826 break;
2827 case TestControlGetBuildNumber:
2828 *((DWORD*)param) = 3102;
2829 break;
2830 }
2831
2832 return Ok;
2833 }
2834
2835 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
2836 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
2837 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
2838 GpMetafile **metafile)
2839 {
2840 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2841 frameUnit, debugstr_w(desc), metafile);
2842
2843 return NotImplemented;
2844 }
2845
2846 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
2847 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
2848 GDIPCONST WCHAR *desc, GpMetafile **metafile)
2849 {
2850 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2851 frameUnit, debugstr_w(desc), metafile);
2852
2853 return NotImplemented;
2854 }
2855
2856 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
2857 {
2858 FIXME("%p\n", image);
2859
2860 return Ok;
2861 }
2862
2863 /*****************************************************************************
2864 * GdipGetImageThumbnail [GDIPLUS.@]
2865 */
2866 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
2867 GpImage **ret_image, GetThumbnailImageAbort cb,
2868 VOID * cb_data)
2869 {
2870 FIXME("(%p %u %u %p %p %p) stub\n",
2871 image, width, height, ret_image, cb, cb_data);
2872 return NotImplemented;
2873 }
2874
2875 /*****************************************************************************
2876 * GdipImageRotateFlip [GDIPLUS.@]
2877 */
2878 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
2879 {
2880 FIXME("(%p %u) stub\n", image, type);
2881 return NotImplemented;
2882 }
A free Windows-compatible Operating System