gdiplus: Fix a memory leak in the tests.
[wine] / dlls / 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 }