?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Don't build wow32.dll when 16-bit support is disabled.
[wine/hacks.git] / dlls / gdiplus / image.c
blobda94ee2746349e7fad7ff0e86d2e61ff781d0f4f
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 FIXME("(%f,%f,%f,%f,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
611
612 return NotImplemented;
613 }
614
615 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
616 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
617 {
618 FIXME("(%i,%i,%i,%i,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
619
620 return NotImplemented;
621 }
622
623 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
624 {
625 GpStatus stat = GenericError;
626
627 TRACE("%p, %p\n", image, cloneImage);
628
629 if (!image || !cloneImage)
630 return InvalidParameter;
631
632 if (image->picture)
633 {
634 IStream* stream;
635 HRESULT hr;
636 INT size;
637 LARGE_INTEGER move;
638
639 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
640 if (FAILED(hr))
641 return GenericError;
642
643 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
644 if(FAILED(hr))
645 {
646 WARN("Failed to save image on stream\n");
647 goto out;
648 }
649
650 /* Set seek pointer back to the beginning of the picture */
651 move.QuadPart = 0;
652 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
653 if (FAILED(hr))
654 goto out;
655
656 stat = GdipLoadImageFromStream(stream, cloneImage);
657 if (stat != Ok) WARN("Failed to load image from stream\n");
658
659 out:
660 IStream_Release(stream);
661 return stat;
662 }
663 else if (image->type == ImageTypeBitmap)
664 {
665 GpBitmap *bitmap = (GpBitmap*)image;
666 BitmapData lockeddata_src, lockeddata_dst;
667 int i;
668 UINT row_size;
669
670 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
671 &lockeddata_src);
672 if (stat != Ok) return stat;
673
674 stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
675 0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
676 if (stat == Ok)
677 {
678 stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
679 lockeddata_src.PixelFormat, &lockeddata_dst);
680
681 if (stat == Ok)
682 {
683 /* copy the image data */
684 row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
685 for (i=0; i<lockeddata_src.Height; i++)
686 memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
687 (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
688 row_size);
689
690 GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
691 }
692
693 GdipBitmapUnlockBits(bitmap, &lockeddata_src);
694 }
695
696 if (stat != Ok)
697 {
698 GdipDisposeImage(*cloneImage);
699 *cloneImage = NULL;
700 }
701 else memcpy(&(*cloneImage)->format, &image->format, sizeof(GUID));
702
703 return stat;
704 }
705 else
706 {
707 ERR("GpImage with no IPicture or bitmap?!\n");
708 return NotImplemented;
709 }
710 }
711
712 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
713 GpBitmap **bitmap)
714 {
715 GpStatus stat;
716 IStream *stream;
717
718 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
719
720 if(!filename || !bitmap)
721 return InvalidParameter;
722
723 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
724
725 if(stat != Ok)
726 return stat;
727
728 stat = GdipCreateBitmapFromStream(stream, bitmap);
729
730 IStream_Release(stream);
731
732 return stat;
733 }
734
735 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
736 VOID *bits, GpBitmap **bitmap)
737 {
738 DWORD height, stride;
739 PixelFormat format;
740
741 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
742
743 height = abs(info->bmiHeader.biHeight);
744 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
745
746 if(info->bmiHeader.biHeight > 0) /* bottom-up */
747 {
748 bits = (BYTE*)bits + (height - 1) * stride;
749 stride = -stride;
750 }
751
752 switch(info->bmiHeader.biBitCount) {
753 case 1:
754 format = PixelFormat1bppIndexed;
755 break;
756 case 4:
757 format = PixelFormat4bppIndexed;
758 break;
759 case 8:
760 format = PixelFormat8bppIndexed;
761 break;
762 case 24:
763 format = PixelFormat24bppRGB;
764 break;
765 default:
766 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
767 *bitmap = NULL;
768 return InvalidParameter;
769 }
770
771 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
772 bits, bitmap);
773
774 }
775
776 /* FIXME: no icm */
777 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
778 GpBitmap **bitmap)
779 {
780 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
781
782 return GdipCreateBitmapFromFile(filename, bitmap);
783 }
784
785 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
786 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
787 {
788 HBITMAP hbm;
789 GpStatus stat = InvalidParameter;
790
791 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
792
793 if(!lpBitmapName || !bitmap)
794 return InvalidParameter;
795
796 /* load DIB */
797 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
798 LR_CREATEDIBSECTION);
799
800 if(hbm){
801 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
802 DeleteObject(hbm);
803 }
804
805 return stat;
806 }
807
808 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
809 HBITMAP* hbmReturn, ARGB background)
810 {
811 GpStatus stat;
812 HBITMAP result, oldbitmap;
813 UINT width, height;
814 HDC hdc;
815 GpGraphics *graphics;
816 BITMAPINFOHEADER bih;
817 void *bits;
818 TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
819
820 if (!bitmap || !hbmReturn) return InvalidParameter;
821
822 GdipGetImageWidth((GpImage*)bitmap, &width);
823 GdipGetImageHeight((GpImage*)bitmap, &height);
824
825 bih.biSize = sizeof(bih);
826 bih.biWidth = width;
827 bih.biHeight = height;
828 bih.biPlanes = 1;
829 bih.biBitCount = 32;
830 bih.biCompression = BI_RGB;
831 bih.biSizeImage = 0;
832 bih.biXPelsPerMeter = 0;
833 bih.biYPelsPerMeter = 0;
834 bih.biClrUsed = 0;
835 bih.biClrImportant = 0;
836
837 hdc = CreateCompatibleDC(NULL);
838 if (!hdc) return GenericError;
839
840 result = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, &bits,
841 NULL, 0);
842
843 if (result)
844 {
845 oldbitmap = SelectObject(hdc, result);
846
847 stat = GdipCreateFromHDC(hdc, &graphics);
848 if (stat == Ok)
849 {
850 stat = GdipGraphicsClear(graphics, background);
851
852 if (stat == Ok)
853 stat = GdipDrawImage(graphics, (GpImage*)bitmap, 0, 0);
854
855 GdipDeleteGraphics(graphics);
856 }
857
858 SelectObject(hdc, oldbitmap);
859 }
860 else
861 stat = GenericError;
862
863 DeleteDC(hdc);
864
865 if (stat != Ok && result)
866 {
867 DeleteObject(result);
868 result = NULL;
869 }
870
871 *hbmReturn = result;
872
873 return stat;
874 }
875
876 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
877 GpMetafile* metafile, BOOL* succ, EmfType emfType,
878 const WCHAR* description, GpMetafile** out_metafile)
879 {
880 static int calls;
881
882 if(!ref || !metafile || !out_metafile)
883 return InvalidParameter;
884
885 *succ = FALSE;
886 *out_metafile = NULL;
887
888 if(!(calls++))
889 FIXME("not implemented\n");
890
891 return NotImplemented;
892 }
893
894 /* FIXME: this should create a bitmap in the given size with the attributes
895 * (resolution etc.) of the graphics object */
896 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
897 GpGraphics* target, GpBitmap** bitmap)
898 {
899 static int calls;
900 GpStatus ret;
901
902 if(!target || !bitmap)
903 return InvalidParameter;
904
905 if(!(calls++))
906 FIXME("hacked stub\n");
907
908 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
909 NULL, bitmap);
910
911 return ret;
912 }
913
914 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
915 {
916 GpStatus stat;
917 ICONINFO iinfo;
918 BITMAP bm;
919 int ret;
920 UINT width, height;
921 GpRect rect;
922 BitmapData lockeddata;
923 HDC screendc;
924 BOOL has_alpha;
925 int x, y;
926 BYTE *bits;
927 BITMAPINFOHEADER bih;
928 DWORD *src;
929 BYTE *dst_row;
930 DWORD *dst;
931
932 TRACE("%p, %p\n", hicon, bitmap);
933
934 if(!bitmap || !GetIconInfo(hicon, &iinfo))
935 {
936 DeleteObject(iinfo.hbmColor);
937 DeleteObject(iinfo.hbmMask);
938 return InvalidParameter;
939 }
940
941 /* get the size of the icon */
942 ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
943 if (ret == 0) {
944 DeleteObject(iinfo.hbmColor);
945 DeleteObject(iinfo.hbmMask);
946 return GenericError;
947 }
948
949 width = bm.bmWidth;
950
951 if (iinfo.hbmColor)
952 height = abs(bm.bmHeight);
953 else /* combined bitmap + mask */
954 height = abs(bm.bmHeight) / 2;
955
956 bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
957 if (!bits) {
958 DeleteObject(iinfo.hbmColor);
959 DeleteObject(iinfo.hbmMask);
960 return OutOfMemory;
961 }
962
963 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
964 if (stat != Ok) {
965 DeleteObject(iinfo.hbmColor);
966 DeleteObject(iinfo.hbmMask);
967 HeapFree(GetProcessHeap(), 0, bits);
968 return stat;
969 }
970
971 rect.X = 0;
972 rect.Y = 0;
973 rect.Width = width;
974 rect.Height = height;
975
976 stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
977 if (stat != Ok) {
978 DeleteObject(iinfo.hbmColor);
979 DeleteObject(iinfo.hbmMask);
980 HeapFree(GetProcessHeap(), 0, bits);
981 GdipDisposeImage((GpImage*)*bitmap);
982 return stat;
983 }
984
985 bih.biSize = sizeof(bih);
986 bih.biWidth = width;
987 bih.biHeight = -height;
988 bih.biPlanes = 1;
989 bih.biBitCount = 32;
990 bih.biCompression = BI_RGB;
991 bih.biSizeImage = 0;
992 bih.biXPelsPerMeter = 0;
993 bih.biYPelsPerMeter = 0;
994 bih.biClrUsed = 0;
995 bih.biClrImportant = 0;
996
997 screendc = GetDC(0);
998 if (iinfo.hbmColor)
999 {
1000 GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1001
1002 if (bm.bmBitsPixel == 32)
1003 {
1004 has_alpha = FALSE;
1005
1006 /* If any pixel has a non-zero alpha, ignore hbmMask */
1007 src = (DWORD*)bits;
1008 for (x=0; x<width && !has_alpha; x++)
1009 for (y=0; y<height && !has_alpha; y++)
1010 if ((*src++ & 0xff000000) != 0)
1011 has_alpha = TRUE;
1012 }
1013 else has_alpha = FALSE;
1014 }
1015 else
1016 {
1017 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1018 has_alpha = FALSE;
1019 }
1020
1021 /* copy the image data to the Bitmap */
1022 src = (DWORD*)bits;
1023 dst_row = lockeddata.Scan0;
1024 for (y=0; y<height; y++)
1025 {
1026 memcpy(dst_row, src, width*4);
1027 src += width;
1028 dst_row += lockeddata.Stride;
1029 }
1030
1031 if (!has_alpha)
1032 {
1033 if (iinfo.hbmMask)
1034 {
1035 /* read alpha data from the mask */
1036 if (iinfo.hbmColor)
1037 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1038 else
1039 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1040
1041 src = (DWORD*)bits;
1042 dst_row = lockeddata.Scan0;
1043 for (y=0; y<height; y++)
1044 {
1045 dst = (DWORD*)dst_row;
1046 for (x=0; x<height; x++)
1047 {
1048 DWORD src_value = *src++;
1049 if (src_value)
1050 *dst++ = 0;
1051 else
1052 *dst++ |= 0xff000000;
1053 }
1054 dst_row += lockeddata.Stride;
1055 }
1056 }
1057 else
1058 {
1059 /* set constant alpha of 255 */
1060 dst_row = bits;
1061 for (y=0; y<height; y++)
1062 {
1063 dst = (DWORD*)dst_row;
1064 for (x=0; x<height; x++)
1065 *dst++ |= 0xff000000;
1066 dst_row += lockeddata.Stride;
1067 }
1068 }
1069 }
1070
1071 ReleaseDC(0, screendc);
1072
1073 DeleteObject(iinfo.hbmColor);
1074 DeleteObject(iinfo.hbmMask);
1075
1076 GdipBitmapUnlockBits(*bitmap, &lockeddata);
1077
1078 HeapFree(GetProcessHeap(), 0, bits);
1079
1080 return Ok;
1081 }
1082
1083 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1084 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1085 {
1086 BITMAPINFOHEADER bmih;
1087 HBITMAP hbitmap;
1088 INT row_size, dib_stride;
1089 HDC hdc;
1090 BYTE *bits;
1091 int i;
1092
1093 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
1094
1095 if (!bitmap) return InvalidParameter;
1096
1097 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1098 *bitmap = NULL;
1099 return InvalidParameter;
1100 }
1101
1102 if(scan0 && !stride)
1103 return InvalidParameter;
1104
1105 row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1106 dib_stride = (row_size + 3) & ~3;
1107
1108 if(stride == 0)
1109 stride = dib_stride;
1110
1111 bmih.biSize = sizeof(BITMAPINFOHEADER);
1112 bmih.biWidth = width;
1113 bmih.biHeight = -height;
1114 bmih.biPlanes = 1;
1115 /* FIXME: use the rest of the data from format */
1116 bmih.biBitCount = PIXELFORMATBPP(format);
1117 bmih.biCompression = BI_RGB;
1118 bmih.biSizeImage = 0;
1119 bmih.biXPelsPerMeter = 0;
1120 bmih.biYPelsPerMeter = 0;
1121 bmih.biClrUsed = 0;
1122 bmih.biClrImportant = 0;
1123
1124 hdc = CreateCompatibleDC(NULL);
1125 if (!hdc) return GenericError;
1126
1127 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits,
1128 NULL, 0);
1129
1130 DeleteDC(hdc);
1131
1132 if (!hbitmap) return GenericError;
1133
1134 /* copy bits to the dib if necessary */
1135 /* FIXME: should reference the bits instead of copying them */
1136 if (scan0)
1137 for (i=0; i<height; i++)
1138 memcpy(bits+i*dib_stride, scan0+i*stride, row_size);
1139
1140 *bitmap = GdipAlloc(sizeof(GpBitmap));
1141 if(!*bitmap)
1142 {
1143 DeleteObject(hbitmap);
1144 return OutOfMemory;
1145 }
1146
1147 (*bitmap)->image.type = ImageTypeBitmap;
1148 memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1149 (*bitmap)->image.flags = ImageFlagsNone;
1150 (*bitmap)->width = width;
1151 (*bitmap)->height = height;
1152 (*bitmap)->format = format;
1153 (*bitmap)->image.picture = NULL;
1154 (*bitmap)->hbitmap = hbitmap;
1155 (*bitmap)->hdc = NULL;
1156 (*bitmap)->bits = bits;
1157 (*bitmap)->stride = dib_stride;
1158
1159 return Ok;
1160 }
1161
1162 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1163 GpBitmap **bitmap)
1164 {
1165 GpStatus stat;
1166
1167 TRACE("%p %p\n", stream, bitmap);
1168
1169 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1170
1171 if(stat != Ok)
1172 return stat;
1173
1174 if((*bitmap)->image.type != ImageTypeBitmap){
1175 GdipDisposeImage(&(*bitmap)->image);
1176 *bitmap = NULL;
1177 return GenericError; /* FIXME: what error to return? */
1178 }
1179
1180 return Ok;
1181 }
1182
1183 /* FIXME: no icm */
1184 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1185 GpBitmap **bitmap)
1186 {
1187 TRACE("%p %p\n", stream, bitmap);
1188
1189 return GdipCreateBitmapFromStream(stream, bitmap);
1190 }
1191
1192 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1193 GpCachedBitmap **cachedbmp)
1194 {
1195 GpStatus stat;
1196
1197 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1198
1199 if(!bitmap || !graphics || !cachedbmp)
1200 return InvalidParameter;
1201
1202 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
1203 if(!*cachedbmp)
1204 return OutOfMemory;
1205
1206 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1207 if(stat != Ok){
1208 GdipFree(*cachedbmp);
1209 return stat;
1210 }
1211
1212 return Ok;
1213 }
1214
1215 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1216 {
1217 FIXME("(%p, %p)\n", bitmap, hicon);
1218
1219 return NotImplemented;
1220 }
1221
1222 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
1223 {
1224 TRACE("%p\n", cachedbmp);
1225
1226 if(!cachedbmp)
1227 return InvalidParameter;
1228
1229 GdipDisposeImage(cachedbmp->image);
1230 GdipFree(cachedbmp);
1231
1232 return Ok;
1233 }
1234
1235 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
1236 GpCachedBitmap *cachedbmp, INT x, INT y)
1237 {
1238 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
1239
1240 if(!graphics || !cachedbmp)
1241 return InvalidParameter;
1242
1243 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
1244 }
1245
1246 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
1247 LPBYTE pData16, INT iMapMode, INT eFlags)
1248 {
1249 FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
1250 return NotImplemented;
1251 }
1252
1253 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
1254 {
1255 TRACE("%p\n", image);
1256
1257 if(!image)
1258 return InvalidParameter;
1259
1260 if (image->picture)
1261 IPicture_Release(image->picture);
1262 if (image->type == ImageTypeBitmap)
1263 {
1264 GdipFree(((GpBitmap*)image)->bitmapbits);
1265 DeleteDC(((GpBitmap*)image)->hdc);
1266 }
1267 GdipFree(image);
1268
1269 return Ok;
1270 }
1271
1272 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
1273 {
1274 if(!image || !item)
1275 return InvalidParameter;
1276
1277 return NotImplemented;
1278 }
1279
1280 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
1281 GpUnit *srcUnit)
1282 {
1283 TRACE("%p %p %p\n", image, srcRect, srcUnit);
1284
1285 if(!image || !srcRect || !srcUnit)
1286 return InvalidParameter;
1287 if(image->type == ImageTypeMetafile){
1288 *srcRect = ((GpMetafile*)image)->bounds;
1289 *srcUnit = ((GpMetafile*)image)->unit;
1290 }
1291 else if(image->type == ImageTypeBitmap){
1292 srcRect->X = srcRect->Y = 0.0;
1293 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
1294 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
1295 *srcUnit = UnitPixel;
1296 }
1297 else{
1298 srcRect->X = srcRect->Y = 0.0;
1299 srcRect->Width = ipicture_pixel_width(image->picture);
1300 srcRect->Height = ipicture_pixel_height(image->picture);
1301 *srcUnit = UnitPixel;
1302 }
1303
1304 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
1305 srcRect->Width, srcRect->Height, *srcUnit);
1306
1307 return Ok;
1308 }
1309
1310 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
1311 REAL *height)
1312 {
1313 TRACE("%p %p %p\n", image, width, height);
1314
1315 if(!image || !height || !width)
1316 return InvalidParameter;
1317
1318 if(image->type == ImageTypeMetafile){
1319 HDC hdc = GetDC(0);
1320
1321 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1322 ((GpMetafile*)image)->bounds.Height;
1323
1324 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1325 ((GpMetafile*)image)->bounds.Width;
1326
1327 ReleaseDC(0, hdc);
1328 }
1329
1330 else if(image->type == ImageTypeBitmap){
1331 *height = ((GpBitmap*)image)->height;
1332 *width = ((GpBitmap*)image)->width;
1333 }
1334 else{
1335 *height = ipicture_pixel_height(image->picture);
1336 *width = ipicture_pixel_width(image->picture);
1337 }
1338
1339 TRACE("returning (%f, %f)\n", *height, *width);
1340 return Ok;
1341 }
1342
1343 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
1344 GpGraphics **graphics)
1345 {
1346 HDC hdc;
1347
1348 TRACE("%p %p\n", image, graphics);
1349
1350 if(!image || !graphics)
1351 return InvalidParameter;
1352
1353 if(image->type != ImageTypeBitmap){
1354 FIXME("not implemented for image type %d\n", image->type);
1355 return NotImplemented;
1356 }
1357
1358 hdc = ((GpBitmap*)image)->hdc;
1359
1360 if(!hdc){
1361 hdc = CreateCompatibleDC(0);
1362 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
1363 ((GpBitmap*)image)->hdc = hdc;
1364 }
1365
1366 return GdipCreateFromHDC(hdc, graphics);
1367 }
1368
1369 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
1370 {
1371 TRACE("%p %p\n", image, height);
1372
1373 if(!image || !height)
1374 return InvalidParameter;
1375
1376 if(image->type == ImageTypeMetafile){
1377 HDC hdc = GetDC(0);
1378
1379 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1380 ((GpMetafile*)image)->bounds.Height);
1381
1382 ReleaseDC(0, hdc);
1383 }
1384 else if(image->type == ImageTypeBitmap)
1385 *height = ((GpBitmap*)image)->height;
1386 else
1387 *height = ipicture_pixel_height(image->picture);
1388
1389 TRACE("returning %d\n", *height);
1390
1391 return Ok;
1392 }
1393
1394 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
1395 {
1396 static int calls;
1397
1398 if(!image || !res)
1399 return InvalidParameter;
1400
1401 if(!(calls++))
1402 FIXME("not implemented\n");
1403
1404 return NotImplemented;
1405 }
1406
1407 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
1408 {
1409 FIXME("%p %p\n", image, size);
1410
1411 if(!image || !size)
1412 return InvalidParameter;
1413
1414 return NotImplemented;
1415 }
1416
1417 /* FIXME: test this function for non-bitmap types */
1418 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
1419 {
1420 TRACE("%p %p\n", image, format);
1421
1422 if(!image || !format)
1423 return InvalidParameter;
1424
1425 if(image->type != ImageTypeBitmap)
1426 *format = PixelFormat24bppRGB;
1427 else
1428 *format = ((GpBitmap*) image)->format;
1429
1430 return Ok;
1431 }
1432
1433 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
1434 {
1435 if(!image || !format)
1436 return InvalidParameter;
1437
1438 memcpy(format, &image->format, sizeof(GUID));
1439
1440 return Ok;
1441 }
1442
1443 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
1444 {
1445 TRACE("%p %p\n", image, type);
1446
1447 if(!image || !type)
1448 return InvalidParameter;
1449
1450 *type = image->type;
1451
1452 return Ok;
1453 }
1454
1455 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
1456 {
1457 static int calls;
1458
1459 if(!image || !res)
1460 return InvalidParameter;
1461
1462 if(!(calls++))
1463 FIXME("not implemented\n");
1464
1465 return NotImplemented;
1466 }
1467
1468 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
1469 {
1470 TRACE("%p %p\n", image, width);
1471
1472 if(!image || !width)
1473 return InvalidParameter;
1474
1475 if(image->type == ImageTypeMetafile){
1476 HDC hdc = GetDC(0);
1477
1478 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1479 ((GpMetafile*)image)->bounds.Width);
1480
1481 ReleaseDC(0, hdc);
1482 }
1483 else if(image->type == ImageTypeBitmap)
1484 *width = ((GpBitmap*)image)->width;
1485 else
1486 *width = ipicture_pixel_width(image->picture);
1487
1488 TRACE("returning %d\n", *width);
1489
1490 return Ok;
1491 }
1492
1493 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
1494 MetafileHeader * header)
1495 {
1496 static int calls;
1497
1498 if(!metafile || !header)
1499 return InvalidParameter;
1500
1501 if(!(calls++))
1502 FIXME("not implemented\n");
1503
1504 return Ok;
1505 }
1506
1507 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
1508 UINT num, PropertyItem* items)
1509 {
1510 static int calls;
1511
1512 if(!(calls++))
1513 FIXME("not implemented\n");
1514
1515 return InvalidParameter;
1516 }
1517
1518 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
1519 {
1520 static int calls;
1521
1522 if(!(calls++))
1523 FIXME("not implemented\n");
1524
1525 return InvalidParameter;
1526 }
1527
1528 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
1529 {
1530 static int calls;
1531
1532 if(!(calls++))
1533 FIXME("not implemented\n");
1534
1535 return InvalidParameter;
1536 }
1537
1538 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
1539 PropertyItem* buffer)
1540 {
1541 static int calls;
1542
1543 if(!(calls++))
1544 FIXME("not implemented\n");
1545
1546 return InvalidParameter;
1547 }
1548
1549 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
1550 UINT* size)
1551 {
1552 static int calls;
1553
1554 TRACE("%p %x %p\n", image, pid, size);
1555
1556 if(!size || !image)
1557 return InvalidParameter;
1558
1559 if(!(calls++))
1560 FIXME("not implemented\n");
1561
1562 return NotImplemented;
1563 }
1564
1565 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
1566 {
1567 static int calls;
1568
1569 if(!(calls++))
1570 FIXME("not implemented\n");
1571
1572 return InvalidParameter;
1573 }
1574
1575 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
1576 GDIPCONST GUID* dimensionID, UINT* count)
1577 {
1578 static int calls;
1579
1580 if(!image || !dimensionID || !count)
1581 return InvalidParameter;
1582
1583 if(!(calls++))
1584 FIXME("not implemented\n");
1585
1586 return NotImplemented;
1587 }
1588
1589 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
1590 UINT* count)
1591 {
1592 if(!image || !count)
1593 return InvalidParameter;
1594
1595 *count = 1;
1596
1597 FIXME("stub\n");
1598
1599 return Ok;
1600 }
1601
1602 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
1603 GUID* dimensionIDs, UINT count)
1604 {
1605 static int calls;
1606
1607 if(!image || !dimensionIDs)
1608 return InvalidParameter;
1609
1610 if(!(calls++))
1611 FIXME("not implemented\n");
1612
1613 return Ok;
1614 }
1615
1616 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
1617 GDIPCONST GUID* dimensionID, UINT frameidx)
1618 {
1619 static int calls;
1620
1621 if(!image || !dimensionID)
1622 return InvalidParameter;
1623
1624 if(!(calls++))
1625 FIXME("not implemented\n");
1626
1627 return Ok;
1628 }
1629
1630 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
1631 GpImage **image)
1632 {
1633 GpStatus stat;
1634 IStream *stream;
1635
1636 TRACE("(%s) %p\n", debugstr_w(filename), image);
1637
1638 if (!filename || !image)
1639 return InvalidParameter;
1640
1641 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1642
1643 if (stat != Ok)
1644 return stat;
1645
1646 stat = GdipLoadImageFromStream(stream, image);
1647
1648 IStream_Release(stream);
1649
1650 return stat;
1651 }
1652
1653 /* FIXME: no icm handling */
1654 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1655 {
1656 TRACE("(%s) %p\n", debugstr_w(filename), image);
1657
1658 return GdipLoadImageFromFile(filename, image);
1659 }
1660
1661 static const WICPixelFormatGUID *wic_pixel_formats[] = {
1662 &GUID_WICPixelFormat16bppBGR555,
1663 &GUID_WICPixelFormat24bppBGR,
1664 &GUID_WICPixelFormat32bppBGR,
1665 &GUID_WICPixelFormat32bppBGRA,
1666 &GUID_WICPixelFormat32bppPBGRA,
1667 NULL
1668 };
1669
1670 static const PixelFormat wic_gdip_formats[] = {
1671 PixelFormat16bppRGB555,
1672 PixelFormat24bppRGB,
1673 PixelFormat32bppRGB,
1674 PixelFormat32bppARGB,
1675 PixelFormat32bppPARGB,
1676 };
1677
1678 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, GpImage **image)
1679 {
1680 GpStatus status=Ok;
1681 GpBitmap *bitmap;
1682 HRESULT hr;
1683 IWICBitmapDecoder *decoder;
1684 IWICBitmapFrameDecode *frame;
1685 IWICBitmapSource *source=NULL;
1686 WICPixelFormatGUID wic_format;
1687 PixelFormat gdip_format=0;
1688 int i;
1689 UINT width, height;
1690 BitmapData lockeddata;
1691 WICRect wrc;
1692 HRESULT initresult;
1693
1694 initresult = CoInitialize(NULL);
1695
1696 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
1697 &IID_IWICBitmapDecoder, (void**)&decoder);
1698 if (FAILED(hr)) goto end;
1699
1700 hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1701 if (SUCCEEDED(hr))
1702 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1703
1704 if (SUCCEEDED(hr)) /* got frame */
1705 {
1706 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
1707
1708 if (SUCCEEDED(hr))
1709 {
1710 for (i=0; wic_pixel_formats[i]; i++)
1711 {
1712 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
1713 {
1714 source = (IWICBitmapSource*)frame;
1715 IWICBitmapSource_AddRef(source);
1716 gdip_format = wic_gdip_formats[i];
1717 break;
1718 }
1719 }
1720 if (!source)
1721 {
1722 /* unknown format; fall back on 32bppARGB */
1723 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
1724 gdip_format = PixelFormat32bppARGB;
1725 }
1726 }
1727
1728 if (SUCCEEDED(hr)) /* got source */
1729 {
1730 hr = IWICBitmapSource_GetSize(source, &width, &height);
1731
1732 if (SUCCEEDED(hr))
1733 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
1734 NULL, &bitmap);
1735
1736 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
1737 {
1738 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
1739 gdip_format, &lockeddata);
1740 if (status == Ok) /* locked bitmap */
1741 {
1742 wrc.X = 0;
1743 wrc.Width = width;
1744 wrc.Height = 1;
1745 for (i=0; i<height; i++)
1746 {
1747 wrc.Y = i;
1748 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
1749 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
1750 if (FAILED(hr)) break;
1751 }
1752
1753 GdipBitmapUnlockBits(bitmap, &lockeddata);
1754 }
1755
1756 if (SUCCEEDED(hr) && status == Ok)
1757 *image = (GpImage*)bitmap;
1758 else
1759 {
1760 *image = NULL;
1761 GdipDisposeImage((GpImage*)bitmap);
1762 }
1763 }
1764
1765 IWICBitmapSource_Release(source);
1766 }
1767
1768 IWICBitmapFrameDecode_Release(frame);
1769 }
1770
1771 IWICBitmapDecoder_Release(decoder);
1772
1773 end:
1774 if (SUCCEEDED(initresult)) CoUninitialize();
1775
1776 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
1777
1778 return status;
1779 }
1780
1781 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, GpImage **image)
1782 {
1783 return decode_image_wic(stream, &CLSID_WICIcoDecoder, image);
1784 }
1785
1786 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, GpImage **image)
1787 {
1788 GpStatus status;
1789 GpBitmap* bitmap;
1790
1791 status = decode_image_wic(stream, &CLSID_WICBmpDecoder, image);
1792
1793 bitmap = (GpBitmap*)*image;
1794
1795 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
1796 {
1797 /* WIC supports bmp files with alpha, but gdiplus does not */
1798 bitmap->format = PixelFormat32bppRGB;
1799 }
1800
1801 return status;
1802 }
1803
1804 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, GpImage **image)
1805 {
1806 return decode_image_wic(stream, &CLSID_WICJpegDecoder, image);
1807 }
1808
1809 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, GpImage **image)
1810 {
1811 return decode_image_wic(stream, &CLSID_WICPngDecoder, image);
1812 }
1813
1814 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, GpImage **image)
1815 {
1816 return decode_image_wic(stream, &CLSID_WICGifDecoder, image);
1817 }
1818
1819 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, GpImage **image)
1820 {
1821 IPicture *pic;
1822
1823 TRACE("%p %p\n", stream, image);
1824
1825 if(!stream || !image)
1826 return InvalidParameter;
1827
1828 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1829 (LPVOID*) &pic) != S_OK){
1830 TRACE("Could not load picture\n");
1831 return GenericError;
1832 }
1833
1834 /* FIXME: missing initialization code */
1835 *image = GdipAlloc(sizeof(GpMetafile));
1836 if(!*image) return OutOfMemory;
1837 (*image)->type = ImageTypeMetafile;
1838 (*image)->picture = pic;
1839 (*image)->flags = ImageFlagsNone;
1840
1841 return Ok;
1842 }
1843
1844 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
1845 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
1846
1847 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, GpImage** image);
1848
1849 typedef struct image_codec {
1850 ImageCodecInfo info;
1851 encode_image_func encode_func;
1852 decode_image_func decode_func;
1853 } image_codec;
1854
1855 typedef enum {
1856 BMP,
1857 JPEG,
1858 GIF,
1859 EMF,
1860 WMF,
1861 PNG,
1862 ICO,
1863 NUM_CODECS
1864 } ImageFormat;
1865
1866 static const struct image_codec codecs[NUM_CODECS];
1867
1868 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
1869 {
1870 BYTE signature[8];
1871 LARGE_INTEGER seek;
1872 HRESULT hr;
1873 UINT bytesread;
1874 int i, j;
1875
1876 /* seek to the start of the stream */
1877 seek.QuadPart = 0;
1878 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1879 if (FAILED(hr)) return hresult_to_status(hr);
1880
1881 /* read the first 8 bytes */
1882 /* FIXME: This assumes all codecs have one signature <= 8 bytes in length */
1883 hr = IStream_Read(stream, signature, 8, &bytesread);
1884 if (FAILED(hr)) return hresult_to_status(hr);
1885 if (hr == S_FALSE || bytesread == 0) return GenericError;
1886
1887 for (i = 0; i < NUM_CODECS; i++) {
1888 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
1889 bytesread >= codecs[i].info.SigSize)
1890 {
1891 for (j=0; j<codecs[i].info.SigSize; j++)
1892 if ((signature[j] & codecs[i].info.SigMask[j]) != codecs[i].info.SigPattern[j])
1893 break;
1894 if (j == codecs[i].info.SigSize)
1895 {
1896 *result = &codecs[i];
1897 return Ok;
1898 }
1899 }
1900 }
1901
1902 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
1903 signature[0],signature[1],signature[2],signature[3],
1904 signature[4],signature[5],signature[6],signature[7]);
1905
1906 return GenericError;
1907 }
1908
1909 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1910 {
1911 GpStatus stat;
1912 LARGE_INTEGER seek;
1913 HRESULT hr;
1914 const struct image_codec *codec=NULL;
1915
1916 /* choose an appropriate image decoder */
1917 stat = get_decoder_info(stream, &codec);
1918 if (stat != Ok) return stat;
1919
1920 /* seek to the start of the stream */
1921 seek.QuadPart = 0;
1922 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1923 if (FAILED(hr)) return hresult_to_status(hr);
1924
1925 /* call on the image decoder to do the real work */
1926 stat = codec->decode_func(stream, &codec->info.Clsid, image);
1927
1928 /* take note of the original data format */
1929 if (stat == Ok)
1930 {
1931 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
1932 }
1933
1934 return stat;
1935 }
1936
1937 /* FIXME: no ICM */
1938 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1939 {
1940 TRACE("%p %p\n", stream, image);
1941
1942 return GdipLoadImageFromStream(stream, image);
1943 }
1944
1945 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1946 {
1947 static int calls;
1948
1949 if(!image)
1950 return InvalidParameter;
1951
1952 if(!(calls++))
1953 FIXME("not implemented\n");
1954
1955 return NotImplemented;
1956 }
1957
1958 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1959 {
1960 static int calls;
1961
1962 if(!(calls++))
1963 FIXME("not implemented\n");
1964
1965 return NotImplemented;
1966 }
1967
1968 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1969 GDIPCONST CLSID *clsidEncoder,
1970 GDIPCONST EncoderParameters *encoderParams)
1971 {
1972 GpStatus stat;
1973 IStream *stream;
1974
1975 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1976
1977 if (!image || !filename|| !clsidEncoder)
1978 return InvalidParameter;
1979
1980 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1981 if (stat != Ok)
1982 return GenericError;
1983
1984 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1985
1986 IStream_Release(stream);
1987 return stat;
1988 }
1989
1990 /*************************************************************************
1991 * Encoding functions -
1992 * These functions encode an image in different image file formats.
1993 */
1994 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1995 #define BITMAP_FORMAT_JPEG 0xd8ff
1996 #define BITMAP_FORMAT_GIF 0x4947
1997 #define BITMAP_FORMAT_PNG 0x5089
1998 #define BITMAP_FORMAT_APM 0xcdd7
1999
2000 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
2001 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2002 {
2003 GpStatus stat;
2004 GpBitmap *bitmap;
2005 IWICBitmapEncoder *encoder;
2006 IWICBitmapFrameEncode *frameencode;
2007 IPropertyBag2 *encoderoptions;
2008 HRESULT hr;
2009 UINT width, height;
2010 PixelFormat gdipformat=0;
2011 WICPixelFormatGUID wicformat;
2012 GpRect rc;
2013 BitmapData lockeddata;
2014 HRESULT initresult;
2015 UINT i;
2016
2017 if (image->type != ImageTypeBitmap)
2018 return GenericError;
2019
2020 bitmap = (GpBitmap*)image;
2021
2022 GdipGetImageWidth(image, &width);
2023 GdipGetImageHeight(image, &height);
2024
2025 rc.X = 0;
2026 rc.Y = 0;
2027 rc.Width = width;
2028 rc.Height = height;
2029
2030 initresult = CoInitialize(NULL);
2031
2032 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2033 &IID_IWICBitmapEncoder, (void**)&encoder);
2034 if (FAILED(hr))
2035 {
2036 if (SUCCEEDED(initresult)) CoUninitialize();
2037 return hresult_to_status(hr);
2038 }
2039
2040 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
2041
2042 if (SUCCEEDED(hr))
2043 {
2044 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
2045 }
2046
2047 if (SUCCEEDED(hr)) /* created frame */
2048 {
2049 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
2050
2051 if (SUCCEEDED(hr))
2052 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
2053
2054 if (SUCCEEDED(hr))
2055 /* FIXME: use the resolution from the image */
2056 hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
2057
2058 if (SUCCEEDED(hr))
2059 {
2060 for (i=0; wic_pixel_formats[i]; i++)
2061 {
2062 if (wic_gdip_formats[i] == bitmap->format)
2063 break;
2064 }
2065 if (wic_pixel_formats[i])
2066 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
2067 else
2068 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
2069
2070 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
2071
2072 for (i=0; wic_pixel_formats[i]; i++)
2073 {
2074 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
2075 break;
2076 }
2077 if (wic_pixel_formats[i])
2078 gdipformat = wic_gdip_formats[i];
2079 else
2080 {
2081 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
2082 hr = E_FAIL;
2083 }
2084 }
2085
2086 if (SUCCEEDED(hr))
2087 {
2088 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
2089 &lockeddata);
2090
2091 if (stat == Ok)
2092 {
2093 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
2094 BYTE *row;
2095
2096 /* write one row at a time in case stride is negative */
2097 row = lockeddata.Scan0;
2098 for (i=0; i<lockeddata.Height; i++)
2099 {
2100 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
2101 if (FAILED(hr)) break;
2102 row += lockeddata.Stride;
2103 }
2104
2105 GdipBitmapUnlockBits(bitmap, &lockeddata);
2106 }
2107 else
2108 hr = E_FAIL;
2109 }
2110
2111 if (SUCCEEDED(hr))
2112 hr = IWICBitmapFrameEncode_Commit(frameencode);
2113
2114 IWICBitmapFrameEncode_Release(frameencode);
2115 IPropertyBag2_Release(encoderoptions);
2116 }
2117
2118 if (SUCCEEDED(hr))
2119 hr = IWICBitmapEncoder_Commit(encoder);
2120
2121 IWICBitmapEncoder_Release(encoder);
2122
2123 if (SUCCEEDED(initresult)) CoUninitialize();
2124
2125 return hresult_to_status(hr);
2126 }
2127
2128 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
2129 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2130 {
2131 return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
2132 }
2133
2134 /*****************************************************************************
2135 * GdipSaveImageToStream [GDIPLUS.@]
2136 */
2137 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
2138 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2139 {
2140 GpStatus stat;
2141 encode_image_func encode_image;
2142 int i;
2143
2144 TRACE("%p %p %p %p\n", image, stream, clsid, params);
2145
2146 if(!image || !stream)
2147 return InvalidParameter;
2148
2149 /* select correct encoder */
2150 encode_image = NULL;
2151 for (i = 0; i < NUM_CODECS; i++) {
2152 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
2153 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
2154 encode_image = codecs[i].encode_func;
2155 }
2156 if (encode_image == NULL)
2157 return UnknownImageFormat;
2158
2159 stat = encode_image(image, stream, clsid, params);
2160
2161 return stat;
2162 }
2163
2164 /*****************************************************************************
2165 * GdipGetImagePalette [GDIPLUS.@]
2166 */
2167 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
2168 {
2169 static int calls = 0;
2170
2171 if(!image)
2172 return InvalidParameter;
2173
2174 if(!(calls++))
2175 FIXME("not implemented\n");
2176
2177 return NotImplemented;
2178 }
2179
2180 /*****************************************************************************
2181 * GdipSetImagePalette [GDIPLUS.@]
2182 */
2183 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
2184 GDIPCONST ColorPalette *palette)
2185 {
2186 static int calls;
2187
2188 if(!image || !palette)
2189 return InvalidParameter;
2190
2191 if(!(calls++))
2192 FIXME("not implemented\n");
2193
2194 return NotImplemented;
2195 }
2196
2197 /*************************************************************************
2198 * Encoders -
2199 * Structures that represent which formats we support for encoding.
2200 */
2201
2202 /* ImageCodecInfo creation routines taken from libgdiplus */
2203 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
2204 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
2205 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
2206 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
2207 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
2208 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
2209
2210 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
2211 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
2212 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
2213 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
2214 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
2215 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
2216
2217 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
2218 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
2219 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
2220 static const WCHAR gif_format[] = {'G','I','F',0};
2221 static const BYTE gif_sig_pattern[4] = "GIF8";
2222 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2223
2224 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
2225 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
2226 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
2227 static const WCHAR emf_format[] = {'E','M','F',0};
2228 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
2229 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2230
2231 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
2232 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
2233 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
2234 static const WCHAR wmf_format[] = {'W','M','F',0};
2235 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
2236 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
2237
2238 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
2239 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
2240 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
2241 static const WCHAR png_format[] = {'P','N','G',0};
2242 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
2243 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2244
2245 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
2246 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
2247 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
2248 static const WCHAR ico_format[] = {'I','C','O',0};
2249 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
2250 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2251
2252 static const struct image_codec codecs[NUM_CODECS] = {
2253 {
2254 { /* BMP */
2255 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2256 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2257 /* CodecName */ bmp_codecname,
2258 /* DllName */ NULL,
2259 /* FormatDescription */ bmp_format,
2260 /* FilenameExtension */ bmp_extension,
2261 /* MimeType */ bmp_mimetype,
2262 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2263 /* Version */ 1,
2264 /* SigCount */ 1,
2265 /* SigSize */ 2,
2266 /* SigPattern */ bmp_sig_pattern,
2267 /* SigMask */ bmp_sig_mask,
2268 },
2269 encode_image_BMP,
2270 decode_image_bmp
2271 },
2272 {
2273 { /* JPEG */
2274 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2275 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2276 /* CodecName */ jpeg_codecname,
2277 /* DllName */ NULL,
2278 /* FormatDescription */ jpeg_format,
2279 /* FilenameExtension */ jpeg_extension,
2280 /* MimeType */ jpeg_mimetype,
2281 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2282 /* Version */ 1,
2283 /* SigCount */ 1,
2284 /* SigSize */ 2,
2285 /* SigPattern */ jpeg_sig_pattern,
2286 /* SigMask */ jpeg_sig_mask,
2287 },
2288 NULL,
2289 decode_image_jpeg
2290 },
2291 {
2292 { /* GIF */
2293 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2294 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2295 /* CodecName */ gif_codecname,
2296 /* DllName */ NULL,
2297 /* FormatDescription */ gif_format,
2298 /* FilenameExtension */ gif_extension,
2299 /* MimeType */ gif_mimetype,
2300 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2301 /* Version */ 1,
2302 /* SigCount */ 1,
2303 /* SigSize */ 4,
2304 /* SigPattern */ gif_sig_pattern,
2305 /* SigMask */ gif_sig_mask,
2306 },
2307 NULL,
2308 decode_image_gif
2309 },
2310 {
2311 { /* EMF */
2312 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2313 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2314 /* CodecName */ emf_codecname,
2315 /* DllName */ NULL,
2316 /* FormatDescription */ emf_format,
2317 /* FilenameExtension */ emf_extension,
2318 /* MimeType */ emf_mimetype,
2319 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2320 /* Version */ 1,
2321 /* SigCount */ 1,
2322 /* SigSize */ 4,
2323 /* SigPattern */ emf_sig_pattern,
2324 /* SigMask */ emf_sig_mask,
2325 },
2326 NULL,
2327 decode_image_olepicture_metafile
2328 },
2329 {
2330 { /* WMF */
2331 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2332 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2333 /* CodecName */ wmf_codecname,
2334 /* DllName */ NULL,
2335 /* FormatDescription */ wmf_format,
2336 /* FilenameExtension */ wmf_extension,
2337 /* MimeType */ wmf_mimetype,
2338 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2339 /* Version */ 1,
2340 /* SigCount */ 1,
2341 /* SigSize */ 2,
2342 /* SigPattern */ wmf_sig_pattern,
2343 /* SigMask */ wmf_sig_mask,
2344 },
2345 NULL,
2346 decode_image_olepicture_metafile
2347 },
2348 {
2349 { /* PNG */
2350 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2351 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2352 /* CodecName */ png_codecname,
2353 /* DllName */ NULL,
2354 /* FormatDescription */ png_format,
2355 /* FilenameExtension */ png_extension,
2356 /* MimeType */ png_mimetype,
2357 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2358 /* Version */ 1,
2359 /* SigCount */ 1,
2360 /* SigSize */ 8,
2361 /* SigPattern */ png_sig_pattern,
2362 /* SigMask */ png_sig_mask,
2363 },
2364 NULL,
2365 decode_image_png
2366 },
2367 {
2368 { /* ICO */
2369 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2370 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2371 /* CodecName */ ico_codecname,
2372 /* DllName */ NULL,
2373 /* FormatDescription */ ico_format,
2374 /* FilenameExtension */ ico_extension,
2375 /* MimeType */ ico_mimetype,
2376 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2377 /* Version */ 1,
2378 /* SigCount */ 1,
2379 /* SigSize */ 4,
2380 /* SigPattern */ ico_sig_pattern,
2381 /* SigMask */ ico_sig_mask,
2382 },
2383 NULL,
2384 decode_image_icon
2385 },
2386 };
2387
2388 /*****************************************************************************
2389 * GdipGetImageDecodersSize [GDIPLUS.@]
2390 */
2391 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
2392 {
2393 int decoder_count=0;
2394 int i;
2395 TRACE("%p %p\n", numDecoders, size);
2396
2397 if (!numDecoders || !size)
2398 return InvalidParameter;
2399
2400 for (i=0; i<NUM_CODECS; i++)
2401 {
2402 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2403 decoder_count++;
2404 }
2405
2406 *numDecoders = decoder_count;
2407 *size = decoder_count * sizeof(ImageCodecInfo);
2408
2409 return Ok;
2410 }
2411
2412 /*****************************************************************************
2413 * GdipGetImageDecoders [GDIPLUS.@]
2414 */
2415 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
2416 {
2417 int i, decoder_count=0;
2418 TRACE("%u %u %p\n", numDecoders, size, decoders);
2419
2420 if (!decoders ||
2421 size != numDecoders * sizeof(ImageCodecInfo))
2422 return GenericError;
2423
2424 for (i=0; i<NUM_CODECS; i++)
2425 {
2426 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2427 {
2428 if (decoder_count == numDecoders) return GenericError;
2429 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2430 decoder_count++;
2431 }
2432 }
2433
2434 if (decoder_count < numDecoders) return GenericError;
2435
2436 return Ok;
2437 }
2438
2439 /*****************************************************************************
2440 * GdipGetImageEncodersSize [GDIPLUS.@]
2441 */
2442 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
2443 {
2444 int encoder_count=0;
2445 int i;
2446 TRACE("%p %p\n", numEncoders, size);
2447
2448 if (!numEncoders || !size)
2449 return InvalidParameter;
2450
2451 for (i=0; i<NUM_CODECS; i++)
2452 {
2453 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2454 encoder_count++;
2455 }
2456
2457 *numEncoders = encoder_count;
2458 *size = encoder_count * sizeof(ImageCodecInfo);
2459
2460 return Ok;
2461 }
2462
2463 /*****************************************************************************
2464 * GdipGetImageEncoders [GDIPLUS.@]
2465 */
2466 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
2467 {
2468 int i, encoder_count=0;
2469 TRACE("%u %u %p\n", numEncoders, size, encoders);
2470
2471 if (!encoders ||
2472 size != numEncoders * sizeof(ImageCodecInfo))
2473 return GenericError;
2474
2475 for (i=0; i<NUM_CODECS; i++)
2476 {
2477 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2478 {
2479 if (encoder_count == numEncoders) return GenericError;
2480 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2481 encoder_count++;
2482 }
2483 }
2484
2485 if (encoder_count < numEncoders) return GenericError;
2486
2487 return Ok;
2488 }
2489
2490 /*****************************************************************************
2491 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
2492 */
2493 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
2494 {
2495 BITMAP bm;
2496 GpStatus retval;
2497 PixelFormat format;
2498 BYTE* bits;
2499
2500 TRACE("%p %p %p\n", hbm, hpal, bitmap);
2501
2502 if(!hbm || !bitmap)
2503 return InvalidParameter;
2504
2505 /* TODO: Support for device-dependent bitmaps */
2506 if(hpal){
2507 FIXME("no support for device-dependent bitmaps\n");
2508 return NotImplemented;
2509 }
2510
2511 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
2512 return InvalidParameter;
2513
2514 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
2515 switch(bm.bmBitsPixel) {
2516 case 1:
2517 format = PixelFormat1bppIndexed;
2518 break;
2519 case 4:
2520 format = PixelFormat4bppIndexed;
2521 break;
2522 case 8:
2523 format = PixelFormat8bppIndexed;
2524 break;
2525 case 24:
2526 format = PixelFormat24bppRGB;
2527 break;
2528 case 32:
2529 format = PixelFormat32bppRGB;
2530 break;
2531 case 48:
2532 format = PixelFormat48bppRGB;
2533 break;
2534 default:
2535 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
2536 return InvalidParameter;
2537 }
2538
2539 if (bm.bmBits)
2540 bits = (BYTE*)bm.bmBits + (bm.bmHeight - 1) * bm.bmWidthBytes;
2541 else
2542 {
2543 FIXME("can only get image data from DIB sections\n");
2544 bits = NULL;
2545 }
2546
2547 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, -bm.bmWidthBytes,
2548 format, bits, bitmap);
2549
2550 return retval;
2551 }
2552
2553 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
2554 {
2555 FIXME("(%p): stub\n", effect);
2556 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
2557 * in Windows's gdiplus */
2558 return NotImplemented;
2559 }
2560
2561 /*****************************************************************************
2562 * GdipSetEffectParameters [GDIPLUS.@]
2563 */
2564 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
2565 const VOID *params, const UINT size)
2566 {
2567 static int calls;
2568
2569 if(!(calls++))
2570 FIXME("not implemented\n");
2571
2572 return NotImplemented;
2573 }
2574
2575 /*****************************************************************************
2576 * GdipGetImageFlags [GDIPLUS.@]
2577 */
2578 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
2579 {
2580 TRACE("%p %p\n", image, flags);
2581
2582 if(!image || !flags)
2583 return InvalidParameter;
2584
2585 *flags = image->flags;
2586
2587 return Ok;
2588 }
2589
2590 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
2591 {
2592 TRACE("(%d, %p)\n", control, param);
2593
2594 switch(control){
2595 case TestControlForceBilinear:
2596 if(param)
2597 FIXME("TestControlForceBilinear not handled\n");
2598 break;
2599 case TestControlNoICM:
2600 if(param)
2601 FIXME("TestControlNoICM not handled\n");
2602 break;
2603 case TestControlGetBuildNumber:
2604 *((DWORD*)param) = 3102;
2605 break;
2606 }
2607
2608 return Ok;
2609 }
2610
2611 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
2612 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
2613 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
2614 GpMetafile **metafile)
2615 {
2616 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2617 frameUnit, debugstr_w(desc), metafile);
2618
2619 return NotImplemented;
2620 }
2621
2622 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
2623 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
2624 GDIPCONST WCHAR *desc, GpMetafile **metafile)
2625 {
2626 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2627 frameUnit, debugstr_w(desc), metafile);
2628
2629 return NotImplemented;
2630 }
2631
2632 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
2633 {
2634 FIXME("%p\n", image);
2635
2636 return Ok;
2637 }
2638
2639 /*****************************************************************************
2640 * GdipGetImageThumbnail [GDIPLUS.@]
2641 */
2642 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
2643 GpImage **ret_image, GetThumbnailImageAbort cb,
2644 VOID * cb_data)
2645 {
2646 FIXME("(%p %u %u %p %p %p) stub\n",
2647 image, width, height, ret_image, cb, cb_data);
2648 return NotImplemented;
2649 }
2650
2651 /*****************************************************************************
2652 * GdipImageRotateFlip [GDIPLUS.@]
2653 */
2654 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
2655 {
2656 FIXME("(%p %u) stub\n", image, type);
2657 return NotImplemented;
2658 }
useful hacks and other patches not (yet) suitable for mainline