2 * Copyright (C) 2007 Google (Evan Stade)
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.
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.
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
21 #define NONAMELESSUNION
36 #include "gdiplus_private.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
41 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
43 static INT ipicture_pixel_height(IPicture *pic)
48 IPicture_get_Height(pic, &y);
52 y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
58 static INT ipicture_pixel_width(IPicture *pic)
63 IPicture_get_Width(pic, &x);
67 x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
74 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
75 RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
77 FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
79 * Note: According to Jose Roca's GDI+ docs, this function is not
80 * implemented in Windows's GDI+.
82 return NotImplemented;
85 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
86 INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
87 GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
89 FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
91 * Note: According to Jose Roca's GDI+ docs, this function is not
92 * implemented in Windows's GDI+.
94 return NotImplemented;
97 static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
98 const BYTE *row, UINT x)
100 *r = *g = *b = row[x*2+1];
104 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
105 const BYTE *row, UINT x)
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);
114 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
115 const BYTE *row, UINT x)
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);
124 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
125 const BYTE *row, UINT x)
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)
137 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
138 const BYTE *row, UINT x)
146 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
147 const BYTE *row, UINT x)
155 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
156 const BYTE *row, UINT x)
164 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
165 const BYTE *row, UINT x)
172 *r = row[x*4+2] * 255 / *a;
173 *g = row[x*4+1] * 255 / *a;
174 *b = row[x*4] * 255 / *a;
178 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
179 const BYTE *row, UINT x)
187 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
188 const BYTE *row, UINT x)
196 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
197 const BYTE *row, UINT x)
204 *r = row[x*8+5] * 255 / *a;
205 *g = row[x*8+3] * 255 / *a;
206 *b = row[x*8+1] * 255 / *a;
210 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
215 TRACE("%p %d %d %p\n", bitmap, x, y, color);
217 if(!bitmap || !color ||
218 x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
219 return InvalidParameter;
221 row = bitmap->bits+bitmap->stride*y;
223 switch (bitmap->format)
225 case PixelFormat16bppGrayScale:
226 getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
228 case PixelFormat16bppRGB555:
229 getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
231 case PixelFormat16bppRGB565:
232 getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
234 case PixelFormat16bppARGB1555:
235 getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
237 case PixelFormat24bppRGB:
238 getpixel_24bppRGB(&r,&g,&b,&a,row,x);
240 case PixelFormat32bppRGB:
241 getpixel_32bppRGB(&r,&g,&b,&a,row,x);
243 case PixelFormat32bppARGB:
244 getpixel_32bppARGB(&r,&g,&b,&a,row,x);
246 case PixelFormat32bppPARGB:
247 getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
249 case PixelFormat48bppRGB:
250 getpixel_48bppRGB(&r,&g,&b,&a,row,x);
252 case PixelFormat64bppARGB:
253 getpixel_64bppARGB(&r,&g,&b,&a,row,x);
255 case PixelFormat64bppPARGB:
256 getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
259 FIXME("not implemented for format 0x%x\n", bitmap->format);
260 return NotImplemented;
263 *color = a<<24|r<<16|g<<8|b;
268 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
271 *((WORD*)(row)+x) = (r+g+b)*85;
274 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
277 *((WORD*)(row)+x) = (r<<7&0x7c00)|
282 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
285 *((WORD*)(row)+x) = (r<<8&0xf800)|
290 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
293 *((WORD*)(row)+x) = (a<<8&0x8000)|
299 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
307 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
310 *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
313 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
316 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
319 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
325 *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
328 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
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;
336 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
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;
343 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
346 UINT64 a64, r64, g64, b64;
351 *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
354 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
359 TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap, x, y, color);
361 if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
362 return InvalidParameter;
369 row = bitmap->bits + bitmap->stride * y;
371 switch (bitmap->format)
373 case PixelFormat16bppGrayScale:
374 setpixel_16bppGrayScale(r,g,b,a,row,x);
376 case PixelFormat16bppRGB555:
377 setpixel_16bppRGB555(r,g,b,a,row,x);
379 case PixelFormat16bppRGB565:
380 setpixel_16bppRGB565(r,g,b,a,row,x);
382 case PixelFormat16bppARGB1555:
383 setpixel_16bppARGB1555(r,g,b,a,row,x);
385 case PixelFormat24bppRGB:
386 setpixel_24bppRGB(r,g,b,a,row,x);
388 case PixelFormat32bppRGB:
389 setpixel_32bppRGB(r,g,b,a,row,x);
391 case PixelFormat32bppARGB:
392 setpixel_32bppARGB(r,g,b,a,row,x);
394 case PixelFormat32bppPARGB:
395 setpixel_32bppPARGB(r,g,b,a,row,x);
397 case PixelFormat48bppRGB:
398 setpixel_48bppRGB(r,g,b,a,row,x);
400 case PixelFormat64bppARGB:
401 setpixel_64bppARGB(r,g,b,a,row,x);
403 case PixelFormat64bppPARGB:
404 setpixel_64bppPARGB(r,g,b,a,row,x);
407 FIXME("not implemented for format 0x%x\n", bitmap->format);
408 return NotImplemented;
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).
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)
424 INT stride, bitspp = PIXELFORMATBPP(format);
426 HBITMAP hbm, old = NULL;
430 GpRect act_rect; /* actual rect to be used */
432 TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
434 if(!lockeddata || !bitmap)
435 return InvalidParameter;
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;
445 act_rect.X = act_rect.Y = 0;
446 act_rect.Width = bitmap->width;
447 act_rect.Height = bitmap->height;
450 if(flags & ImageLockModeUserInputBuf)
451 return NotImplemented;
456 if (bitmap->bits && bitmap->format == format)
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;
467 bitmap->lockmode = flags;
473 hbm = bitmap->hbitmap;
475 bm_is_selected = (hdc != 0);
477 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
480 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
481 pbmi->bmiHeader.biBitCount = 0;
484 hdc = CreateCompatibleDC(0);
485 old = SelectObject(hdc, hbm);
489 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
491 abs_height = abs(pbmi->bmiHeader.biHeight);
492 stride = pbmi->bmiHeader.biWidth * bitspp / 8;
493 stride = (stride + 3) & ~3;
495 buff = GdipAlloc(stride * abs_height);
497 pbmi->bmiHeader.biBitCount = bitspp;
500 GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
503 SelectObject(hdc, old);
512 lockeddata->Width = act_rect.Width;
513 lockeddata->Height = act_rect.Height;
514 lockeddata->PixelFormat = format;
515 lockeddata->Reserved = flags;
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);
523 lockeddata->Stride = stride;
524 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
527 bitmap->lockmode = flags;
530 bitmap->bitmapbits = buff;
536 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
538 FIXME("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
540 return NotImplemented;
543 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
544 BitmapData* lockeddata)
547 HBITMAP hbm, old = NULL;
551 if(!bitmap || !lockeddata)
552 return InvalidParameter;
554 if(!bitmap->lockmode)
557 if(lockeddata->Reserved & ImageLockModeUserInputBuf)
558 return NotImplemented;
560 if(lockeddata->Reserved & ImageLockModeRead){
561 if(!(--bitmap->numlocks))
562 bitmap->lockmode = 0;
564 GdipFree(bitmap->bitmapbits);
565 bitmap->bitmapbits = NULL;
569 if (!bitmap->bitmapbits)
571 /* we passed a direct reference; no need to do anything */
572 bitmap->lockmode = 0;
576 hbm = bitmap->hbitmap;
578 bm_is_selected = (hdc != 0);
580 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
581 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
582 pbmi->bmiHeader.biBitCount = 0;
585 hdc = CreateCompatibleDC(0);
586 old = SelectObject(hdc, hbm);
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);
595 SelectObject(hdc, old);
600 GdipFree(bitmap->bitmapbits);
601 bitmap->bitmapbits = NULL;
602 bitmap->lockmode = 0;
607 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
608 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
610 FIXME("(%f,%f,%f,%f,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
612 return NotImplemented;
615 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
616 PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
618 FIXME("(%i,%i,%i,%i,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
620 return NotImplemented;
623 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
625 GpStatus stat = GenericError;
627 TRACE("%p, %p\n", image, cloneImage);
629 if (!image || !cloneImage)
630 return InvalidParameter;
639 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
643 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
646 WARN("Failed to save image on stream\n");
650 /* Set seek pointer back to the beginning of the picture */
652 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
656 stat = GdipLoadImageFromStream(stream, cloneImage);
657 if (stat != Ok) WARN("Failed to load image from stream\n");
660 IStream_Release(stream);
663 else if (image->type == ImageTypeBitmap)
665 GpBitmap *bitmap = (GpBitmap*)image;
666 BitmapData lockeddata_src, lockeddata_dst;
670 stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
672 if (stat != Ok) return stat;
674 stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
675 0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
678 stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
679 lockeddata_src.PixelFormat, &lockeddata_dst);
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,
690 GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
693 GdipBitmapUnlockBits(bitmap, &lockeddata_src);
698 GdipDisposeImage(*cloneImage);
701 else memcpy(&(*cloneImage)->format, &image->format, sizeof(GUID));
707 ERR("GpImage with no IPicture or bitmap?!\n");
708 return NotImplemented;
712 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
718 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
720 if(!filename || !bitmap)
721 return InvalidParameter;
723 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
728 stat = GdipCreateBitmapFromStream(stream, bitmap);
730 IStream_Release(stream);
735 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
736 VOID *bits, GpBitmap **bitmap)
738 DWORD height, stride;
741 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
743 height = abs(info->bmiHeader.biHeight);
744 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
746 if(info->bmiHeader.biHeight > 0) /* bottom-up */
748 bits = (BYTE*)bits + (height - 1) * stride;
752 switch(info->bmiHeader.biBitCount) {
754 format = PixelFormat1bppIndexed;
757 format = PixelFormat4bppIndexed;
760 format = PixelFormat8bppIndexed;
763 format = PixelFormat24bppRGB;
766 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
768 return InvalidParameter;
771 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
777 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
780 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
782 return GdipCreateBitmapFromFile(filename, bitmap);
785 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
786 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
789 GpStatus stat = InvalidParameter;
791 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
793 if(!lpBitmapName || !bitmap)
794 return InvalidParameter;
797 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
798 LR_CREATEDIBSECTION);
801 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
808 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
809 HBITMAP* hbmReturn, ARGB background)
812 HBITMAP result, oldbitmap;
815 GpGraphics *graphics;
816 BITMAPINFOHEADER bih;
818 TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
820 if (!bitmap || !hbmReturn) return InvalidParameter;
822 GdipGetImageWidth((GpImage*)bitmap, &width);
823 GdipGetImageHeight((GpImage*)bitmap, &height);
825 bih.biSize = sizeof(bih);
827 bih.biHeight = height;
830 bih.biCompression = BI_RGB;
832 bih.biXPelsPerMeter = 0;
833 bih.biYPelsPerMeter = 0;
835 bih.biClrImportant = 0;
837 hdc = CreateCompatibleDC(NULL);
838 if (!hdc) return GenericError;
840 result = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, &bits,
845 oldbitmap = SelectObject(hdc, result);
847 stat = GdipCreateFromHDC(hdc, &graphics);
850 stat = GdipGraphicsClear(graphics, background);
853 stat = GdipDrawImage(graphics, (GpImage*)bitmap, 0, 0);
855 GdipDeleteGraphics(graphics);
858 SelectObject(hdc, oldbitmap);
865 if (stat != Ok && result)
867 DeleteObject(result);
876 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
877 GpMetafile* metafile, BOOL* succ, EmfType emfType,
878 const WCHAR* description, GpMetafile** out_metafile)
882 if(!ref || !metafile || !out_metafile)
883 return InvalidParameter;
886 *out_metafile = NULL;
889 FIXME("not implemented\n");
891 return NotImplemented;
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)
902 if(!target || !bitmap)
903 return InvalidParameter;
906 FIXME("hacked stub\n");
908 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
914 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
922 BitmapData lockeddata;
927 BITMAPINFOHEADER bih;
932 TRACE("%p, %p\n", hicon, bitmap);
934 if(!bitmap || !GetIconInfo(hicon, &iinfo))
935 return InvalidParameter;
937 /* get the size of the icon */
938 ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
940 DeleteObject(iinfo.hbmColor);
941 DeleteObject(iinfo.hbmMask);
948 height = abs(bm.bmHeight);
949 else /* combined bitmap + mask */
950 height = abs(bm.bmHeight) / 2;
952 bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
954 DeleteObject(iinfo.hbmColor);
955 DeleteObject(iinfo.hbmMask);
959 stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
961 DeleteObject(iinfo.hbmColor);
962 DeleteObject(iinfo.hbmMask);
963 HeapFree(GetProcessHeap(), 0, bits);
970 rect.Height = height;
972 stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
974 DeleteObject(iinfo.hbmColor);
975 DeleteObject(iinfo.hbmMask);
976 HeapFree(GetProcessHeap(), 0, bits);
977 GdipDisposeImage((GpImage*)*bitmap);
981 bih.biSize = sizeof(bih);
983 bih.biHeight = -height;
986 bih.biCompression = BI_RGB;
988 bih.biXPelsPerMeter = 0;
989 bih.biYPelsPerMeter = 0;
991 bih.biClrImportant = 0;
996 GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
998 if (bm.bmBitsPixel == 32)
1002 /* If any pixel has a non-zero alpha, ignore hbmMask */
1004 for (x=0; x<width && !has_alpha; x++)
1005 for (y=0; y<height && !has_alpha; y++)
1006 if ((*src++ & 0xff000000) != 0)
1009 else has_alpha = FALSE;
1013 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1017 /* copy the image data to the Bitmap */
1019 dst_row = lockeddata.Scan0;
1020 for (y=0; y<height; y++)
1022 memcpy(dst_row, src, width*4);
1024 dst_row += lockeddata.Stride;
1031 /* read alpha data from the mask */
1033 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1035 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1038 dst_row = lockeddata.Scan0;
1039 for (y=0; y<height; y++)
1041 dst = (DWORD*)dst_row;
1042 for (x=0; x<height; x++)
1044 DWORD src_value = *src++;
1048 *dst++ |= 0xff000000;
1050 dst_row += lockeddata.Stride;
1055 /* set constant alpha of 255 */
1057 for (y=0; y<height; y++)
1059 dst = (DWORD*)dst_row;
1060 for (x=0; x<height; x++)
1061 *dst++ |= 0xff000000;
1062 dst_row += lockeddata.Stride;
1067 ReleaseDC(0, screendc);
1069 DeleteObject(iinfo.hbmColor);
1070 DeleteObject(iinfo.hbmMask);
1072 GdipBitmapUnlockBits(*bitmap, &lockeddata);
1074 HeapFree(GetProcessHeap(), 0, bits);
1079 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1080 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1082 BITMAPINFOHEADER bmih;
1084 INT row_size, dib_stride;
1089 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
1091 if (!bitmap) return InvalidParameter;
1093 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1095 return InvalidParameter;
1098 if(scan0 && !stride)
1099 return InvalidParameter;
1101 row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1102 dib_stride = (row_size + 3) & ~3;
1105 stride = dib_stride;
1107 bmih.biSize = sizeof(BITMAPINFOHEADER);
1108 bmih.biWidth = width;
1109 bmih.biHeight = -height;
1111 /* FIXME: use the rest of the data from format */
1112 bmih.biBitCount = PIXELFORMATBPP(format);
1113 bmih.biCompression = BI_RGB;
1114 bmih.biSizeImage = 0;
1115 bmih.biXPelsPerMeter = 0;
1116 bmih.biYPelsPerMeter = 0;
1118 bmih.biClrImportant = 0;
1120 hdc = CreateCompatibleDC(NULL);
1121 if (!hdc) return GenericError;
1123 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits,
1128 if (!hbitmap) return GenericError;
1130 /* copy bits to the dib if necessary */
1131 /* FIXME: should reference the bits instead of copying them */
1133 for (i=0; i<height; i++)
1134 memcpy(bits+i*dib_stride, scan0+i*stride, row_size);
1136 *bitmap = GdipAlloc(sizeof(GpBitmap));
1139 DeleteObject(hbitmap);
1143 (*bitmap)->image.type = ImageTypeBitmap;
1144 memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1145 (*bitmap)->image.flags = ImageFlagsNone;
1146 (*bitmap)->width = width;
1147 (*bitmap)->height = height;
1148 (*bitmap)->format = format;
1149 (*bitmap)->image.picture = NULL;
1150 (*bitmap)->hbitmap = hbitmap;
1151 (*bitmap)->hdc = NULL;
1152 (*bitmap)->bits = bits;
1153 (*bitmap)->stride = dib_stride;
1158 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1163 TRACE("%p %p\n", stream, bitmap);
1165 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1170 if((*bitmap)->image.type != ImageTypeBitmap){
1171 GdipDisposeImage(&(*bitmap)->image);
1173 return GenericError; /* FIXME: what error to return? */
1180 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1183 TRACE("%p %p\n", stream, bitmap);
1185 return GdipCreateBitmapFromStream(stream, bitmap);
1188 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1189 GpCachedBitmap **cachedbmp)
1193 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1195 if(!bitmap || !graphics || !cachedbmp)
1196 return InvalidParameter;
1198 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
1202 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1204 GdipFree(*cachedbmp);
1211 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1213 FIXME("(%p, %p)\n", bitmap, hicon);
1215 return NotImplemented;
1218 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
1220 TRACE("%p\n", cachedbmp);
1223 return InvalidParameter;
1225 GdipDisposeImage(cachedbmp->image);
1226 GdipFree(cachedbmp);
1231 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
1232 GpCachedBitmap *cachedbmp, INT x, INT y)
1234 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
1236 if(!graphics || !cachedbmp)
1237 return InvalidParameter;
1239 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
1242 GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
1243 LPBYTE pData16, INT iMapMode, INT eFlags)
1245 FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
1246 return NotImplemented;
1249 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
1251 TRACE("%p\n", image);
1254 return InvalidParameter;
1257 IPicture_Release(image->picture);
1258 if (image->type == ImageTypeBitmap)
1260 GdipFree(((GpBitmap*)image)->bitmapbits);
1261 DeleteDC(((GpBitmap*)image)->hdc);
1268 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
1271 return InvalidParameter;
1273 return NotImplemented;
1276 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
1279 TRACE("%p %p %p\n", image, srcRect, srcUnit);
1281 if(!image || !srcRect || !srcUnit)
1282 return InvalidParameter;
1283 if(image->type == ImageTypeMetafile){
1284 *srcRect = ((GpMetafile*)image)->bounds;
1285 *srcUnit = ((GpMetafile*)image)->unit;
1287 else if(image->type == ImageTypeBitmap){
1288 srcRect->X = srcRect->Y = 0.0;
1289 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
1290 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
1291 *srcUnit = UnitPixel;
1294 srcRect->X = srcRect->Y = 0.0;
1295 srcRect->Width = ipicture_pixel_width(image->picture);
1296 srcRect->Height = ipicture_pixel_height(image->picture);
1297 *srcUnit = UnitPixel;
1300 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
1301 srcRect->Width, srcRect->Height, *srcUnit);
1306 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
1309 TRACE("%p %p %p\n", image, width, height);
1311 if(!image || !height || !width)
1312 return InvalidParameter;
1314 if(image->type == ImageTypeMetafile){
1317 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1318 ((GpMetafile*)image)->bounds.Height;
1320 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
1321 ((GpMetafile*)image)->bounds.Width;
1326 else if(image->type == ImageTypeBitmap){
1327 *height = ((GpBitmap*)image)->height;
1328 *width = ((GpBitmap*)image)->width;
1331 *height = ipicture_pixel_height(image->picture);
1332 *width = ipicture_pixel_width(image->picture);
1335 TRACE("returning (%f, %f)\n", *height, *width);
1339 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
1340 GpGraphics **graphics)
1344 TRACE("%p %p\n", image, graphics);
1346 if(!image || !graphics)
1347 return InvalidParameter;
1349 if(image->type != ImageTypeBitmap){
1350 FIXME("not implemented for image type %d\n", image->type);
1351 return NotImplemented;
1354 hdc = ((GpBitmap*)image)->hdc;
1357 hdc = CreateCompatibleDC(0);
1358 SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
1359 ((GpBitmap*)image)->hdc = hdc;
1362 return GdipCreateFromHDC(hdc, graphics);
1365 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
1367 TRACE("%p %p\n", image, height);
1369 if(!image || !height)
1370 return InvalidParameter;
1372 if(image->type == ImageTypeMetafile){
1375 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1376 ((GpMetafile*)image)->bounds.Height);
1380 else if(image->type == ImageTypeBitmap)
1381 *height = ((GpBitmap*)image)->height;
1383 *height = ipicture_pixel_height(image->picture);
1385 TRACE("returning %d\n", *height);
1390 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
1395 return InvalidParameter;
1398 FIXME("not implemented\n");
1400 return NotImplemented;
1403 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
1405 FIXME("%p %p\n", image, size);
1408 return InvalidParameter;
1410 return NotImplemented;
1413 /* FIXME: test this function for non-bitmap types */
1414 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
1416 TRACE("%p %p\n", image, format);
1418 if(!image || !format)
1419 return InvalidParameter;
1421 if(image->type != ImageTypeBitmap)
1422 *format = PixelFormat24bppRGB;
1424 *format = ((GpBitmap*) image)->format;
1429 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
1431 if(!image || !format)
1432 return InvalidParameter;
1434 memcpy(format, &image->format, sizeof(GUID));
1439 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
1441 TRACE("%p %p\n", image, type);
1444 return InvalidParameter;
1446 *type = image->type;
1451 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
1456 return InvalidParameter;
1459 FIXME("not implemented\n");
1461 return NotImplemented;
1464 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
1466 TRACE("%p %p\n", image, width);
1468 if(!image || !width)
1469 return InvalidParameter;
1471 if(image->type == ImageTypeMetafile){
1474 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
1475 ((GpMetafile*)image)->bounds.Width);
1479 else if(image->type == ImageTypeBitmap)
1480 *width = ((GpBitmap*)image)->width;
1482 *width = ipicture_pixel_width(image->picture);
1484 TRACE("returning %d\n", *width);
1489 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
1490 MetafileHeader * header)
1494 if(!metafile || !header)
1495 return InvalidParameter;
1498 FIXME("not implemented\n");
1503 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
1504 UINT num, PropertyItem* items)
1509 FIXME("not implemented\n");
1511 return InvalidParameter;
1514 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
1519 FIXME("not implemented\n");
1521 return InvalidParameter;
1524 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
1529 FIXME("not implemented\n");
1531 return InvalidParameter;
1534 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
1535 PropertyItem* buffer)
1540 FIXME("not implemented\n");
1542 return InvalidParameter;
1545 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
1550 TRACE("%p %x %p\n", image, pid, size);
1553 return InvalidParameter;
1556 FIXME("not implemented\n");
1558 return NotImplemented;
1561 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
1566 FIXME("not implemented\n");
1568 return InvalidParameter;
1571 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
1572 GDIPCONST GUID* dimensionID, UINT* count)
1576 if(!image || !dimensionID || !count)
1577 return InvalidParameter;
1580 FIXME("not implemented\n");
1582 return NotImplemented;
1585 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
1588 if(!image || !count)
1589 return InvalidParameter;
1598 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
1599 GUID* dimensionIDs, UINT count)
1603 if(!image || !dimensionIDs)
1604 return InvalidParameter;
1607 FIXME("not implemented\n");
1612 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
1613 GDIPCONST GUID* dimensionID, UINT frameidx)
1617 if(!image || !dimensionID)
1618 return InvalidParameter;
1621 FIXME("not implemented\n");
1626 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
1632 TRACE("(%s) %p\n", debugstr_w(filename), image);
1634 if (!filename || !image)
1635 return InvalidParameter;
1637 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1642 stat = GdipLoadImageFromStream(stream, image);
1644 IStream_Release(stream);
1649 /* FIXME: no icm handling */
1650 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1652 TRACE("(%s) %p\n", debugstr_w(filename), image);
1654 return GdipLoadImageFromFile(filename, image);
1657 static const WICPixelFormatGUID *wic_pixel_formats[] = {
1658 &GUID_WICPixelFormat16bppBGR555,
1659 &GUID_WICPixelFormat24bppBGR,
1660 &GUID_WICPixelFormat32bppBGR,
1661 &GUID_WICPixelFormat32bppBGRA,
1662 &GUID_WICPixelFormat32bppPBGRA,
1666 static const PixelFormat wic_gdip_formats[] = {
1667 PixelFormat16bppRGB555,
1668 PixelFormat24bppRGB,
1669 PixelFormat32bppRGB,
1670 PixelFormat32bppARGB,
1671 PixelFormat32bppPARGB,
1674 static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, GpImage **image)
1679 IWICBitmapDecoder *decoder;
1680 IWICBitmapFrameDecode *frame;
1681 IWICBitmapSource *source=NULL;
1682 WICPixelFormatGUID wic_format;
1683 PixelFormat gdip_format=0;
1686 BitmapData lockeddata;
1690 initresult = CoInitialize(NULL);
1692 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
1693 &IID_IWICBitmapDecoder, (void**)&decoder);
1694 if (FAILED(hr)) goto end;
1696 hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
1698 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
1700 if (SUCCEEDED(hr)) /* got frame */
1702 hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
1706 for (i=0; wic_pixel_formats[i]; i++)
1708 if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
1710 source = (IWICBitmapSource*)frame;
1711 IWICBitmapSource_AddRef(source);
1712 gdip_format = wic_gdip_formats[i];
1718 /* unknown format; fall back on 32bppARGB */
1719 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
1720 gdip_format = PixelFormat32bppARGB;
1724 if (SUCCEEDED(hr)) /* got source */
1726 hr = IWICBitmapSource_GetSize(source, &width, &height);
1729 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
1732 if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
1734 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
1735 gdip_format, &lockeddata);
1736 if (status == Ok) /* locked bitmap */
1741 for (i=0; i<height; i++)
1744 hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
1745 abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
1746 if (FAILED(hr)) break;
1749 GdipBitmapUnlockBits(bitmap, &lockeddata);
1752 if (SUCCEEDED(hr) && status == Ok)
1753 *image = (GpImage*)bitmap;
1757 GdipDisposeImage((GpImage*)bitmap);
1761 IWICBitmapSource_Release(source);
1764 IWICBitmapFrameDecode_Release(frame);
1767 IWICBitmapDecoder_Release(decoder);
1770 if (SUCCEEDED(initresult)) CoUninitialize();
1772 if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
1777 static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, GpImage **image)
1779 return decode_image_wic(stream, &CLSID_WICIcoDecoder, image);
1782 static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, GpImage **image)
1787 status = decode_image_wic(stream, &CLSID_WICBmpDecoder, image);
1789 bitmap = (GpBitmap*)*image;
1791 if (status == Ok && bitmap->format == PixelFormat32bppARGB)
1793 /* WIC supports bmp files with alpha, but gdiplus does not */
1794 bitmap->format = PixelFormat32bppRGB;
1800 static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, GpImage **image)
1802 return decode_image_wic(stream, &CLSID_WICJpegDecoder, image);
1805 static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, GpImage **image)
1807 return decode_image_wic(stream, &CLSID_WICPngDecoder, image);
1810 static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, GpImage **image)
1812 return decode_image_wic(stream, &CLSID_WICGifDecoder, image);
1815 static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, GpImage **image)
1819 TRACE("%p %p\n", stream, image);
1821 if(!stream || !image)
1822 return InvalidParameter;
1824 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1825 (LPVOID*) &pic) != S_OK){
1826 TRACE("Could not load picture\n");
1827 return GenericError;
1830 /* FIXME: missing initialization code */
1831 *image = GdipAlloc(sizeof(GpMetafile));
1832 if(!*image) return OutOfMemory;
1833 (*image)->type = ImageTypeMetafile;
1834 (*image)->picture = pic;
1835 (*image)->flags = ImageFlagsNone;
1840 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
1841 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
1843 typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, GpImage** image);
1845 typedef struct image_codec {
1846 ImageCodecInfo info;
1847 encode_image_func encode_func;
1848 decode_image_func decode_func;
1862 static const struct image_codec codecs[NUM_CODECS];
1864 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
1872 /* seek to the start of the stream */
1874 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1875 if (FAILED(hr)) return hresult_to_status(hr);
1877 /* read the first 8 bytes */
1878 /* FIXME: This assumes all codecs have one signature <= 8 bytes in length */
1879 hr = IStream_Read(stream, signature, 8, &bytesread);
1880 if (FAILED(hr)) return hresult_to_status(hr);
1881 if (hr == S_FALSE || bytesread == 0) return GenericError;
1883 for (i = 0; i < NUM_CODECS; i++) {
1884 if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
1885 bytesread >= codecs[i].info.SigSize)
1887 for (j=0; j<codecs[i].info.SigSize; j++)
1888 if ((signature[j] & codecs[i].info.SigMask[j]) != codecs[i].info.SigPattern[j])
1890 if (j == codecs[i].info.SigSize)
1892 *result = &codecs[i];
1898 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
1899 signature[0],signature[1],signature[2],signature[3],
1900 signature[4],signature[5],signature[6],signature[7]);
1902 return GenericError;
1905 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1910 const struct image_codec *codec=NULL;
1912 /* choose an appropriate image decoder */
1913 stat = get_decoder_info(stream, &codec);
1914 if (stat != Ok) return stat;
1916 /* seek to the start of the stream */
1918 hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
1919 if (FAILED(hr)) return hresult_to_status(hr);
1921 /* call on the image decoder to do the real work */
1922 stat = codec->decode_func(stream, &codec->info.Clsid, image);
1924 /* take note of the original data format */
1927 memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
1934 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1936 TRACE("%p %p\n", stream, image);
1938 return GdipLoadImageFromStream(stream, image);
1941 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1946 return InvalidParameter;
1949 FIXME("not implemented\n");
1951 return NotImplemented;
1954 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1959 FIXME("not implemented\n");
1961 return NotImplemented;
1964 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1965 GDIPCONST CLSID *clsidEncoder,
1966 GDIPCONST EncoderParameters *encoderParams)
1971 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1973 if (!image || !filename|| !clsidEncoder)
1974 return InvalidParameter;
1976 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1978 return GenericError;
1980 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1982 IStream_Release(stream);
1986 /*************************************************************************
1987 * Encoding functions -
1988 * These functions encode an image in different image file formats.
1990 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1991 #define BITMAP_FORMAT_JPEG 0xd8ff
1992 #define BITMAP_FORMAT_GIF 0x4947
1993 #define BITMAP_FORMAT_PNG 0x5089
1994 #define BITMAP_FORMAT_APM 0xcdd7
1996 static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
1997 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2001 IWICBitmapEncoder *encoder;
2002 IWICBitmapFrameEncode *frameencode;
2003 IPropertyBag2 *encoderoptions;
2006 PixelFormat gdipformat=0;
2007 WICPixelFormatGUID wicformat;
2009 BitmapData lockeddata;
2013 if (image->type != ImageTypeBitmap)
2014 return GenericError;
2016 bitmap = (GpBitmap*)image;
2018 GdipGetImageWidth(image, &width);
2019 GdipGetImageHeight(image, &height);
2026 initresult = CoInitialize(NULL);
2028 hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
2029 &IID_IWICBitmapEncoder, (void**)&encoder);
2032 if (SUCCEEDED(initresult)) CoUninitialize();
2033 return hresult_to_status(hr);
2036 hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
2040 hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
2043 if (SUCCEEDED(hr)) /* created frame */
2045 hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
2048 hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
2051 /* FIXME: use the resolution from the image */
2052 hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
2056 for (i=0; wic_pixel_formats[i]; i++)
2058 if (wic_gdip_formats[i] == bitmap->format)
2061 if (wic_pixel_formats[i])
2062 memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
2064 memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
2066 hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
2068 for (i=0; wic_pixel_formats[i]; i++)
2070 if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
2073 if (wic_pixel_formats[i])
2074 gdipformat = wic_gdip_formats[i];
2077 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
2084 stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
2089 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
2092 /* write one row at a time in case stride is negative */
2093 row = lockeddata.Scan0;
2094 for (i=0; i<lockeddata.Height; i++)
2096 hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
2097 if (FAILED(hr)) break;
2098 row += lockeddata.Stride;
2101 GdipBitmapUnlockBits(bitmap, &lockeddata);
2108 hr = IWICBitmapFrameEncode_Commit(frameencode);
2110 IWICBitmapFrameEncode_Release(frameencode);
2111 IPropertyBag2_Release(encoderoptions);
2115 hr = IWICBitmapEncoder_Commit(encoder);
2117 IWICBitmapEncoder_Release(encoder);
2119 if (SUCCEEDED(initresult)) CoUninitialize();
2121 return hresult_to_status(hr);
2124 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
2125 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2127 return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
2130 static GpStatus encode_image_png(GpImage *image, IStream* stream,
2131 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2133 return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
2136 /*****************************************************************************
2137 * GdipSaveImageToStream [GDIPLUS.@]
2139 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
2140 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
2143 encode_image_func encode_image;
2146 TRACE("%p %p %p %p\n", image, stream, clsid, params);
2148 if(!image || !stream)
2149 return InvalidParameter;
2151 /* select correct encoder */
2152 encode_image = NULL;
2153 for (i = 0; i < NUM_CODECS; i++) {
2154 if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
2155 IsEqualCLSID(clsid, &codecs[i].info.Clsid))
2156 encode_image = codecs[i].encode_func;
2158 if (encode_image == NULL)
2159 return UnknownImageFormat;
2161 stat = encode_image(image, stream, clsid, params);
2166 /*****************************************************************************
2167 * GdipGetImagePalette [GDIPLUS.@]
2169 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
2171 static int calls = 0;
2174 return InvalidParameter;
2177 FIXME("not implemented\n");
2179 return NotImplemented;
2182 /*****************************************************************************
2183 * GdipSetImagePalette [GDIPLUS.@]
2185 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
2186 GDIPCONST ColorPalette *palette)
2190 if(!image || !palette)
2191 return InvalidParameter;
2194 FIXME("not implemented\n");
2196 return NotImplemented;
2199 /*************************************************************************
2201 * Structures that represent which formats we support for encoding.
2204 /* ImageCodecInfo creation routines taken from libgdiplus */
2205 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
2206 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
2207 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
2208 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
2209 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
2210 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
2212 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
2213 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
2214 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
2215 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
2216 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
2217 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
2219 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
2220 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
2221 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
2222 static const WCHAR gif_format[] = {'G','I','F',0};
2223 static const BYTE gif_sig_pattern[4] = "GIF8";
2224 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2226 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
2227 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
2228 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
2229 static const WCHAR emf_format[] = {'E','M','F',0};
2230 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
2231 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2233 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
2234 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
2235 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
2236 static const WCHAR wmf_format[] = {'W','M','F',0};
2237 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
2238 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
2240 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
2241 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
2242 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
2243 static const WCHAR png_format[] = {'P','N','G',0};
2244 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
2245 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2247 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
2248 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
2249 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
2250 static const WCHAR ico_format[] = {'I','C','O',0};
2251 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
2252 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2254 static const struct image_codec codecs[NUM_CODECS] = {
2257 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2258 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2259 /* CodecName */ bmp_codecname,
2261 /* FormatDescription */ bmp_format,
2262 /* FilenameExtension */ bmp_extension,
2263 /* MimeType */ bmp_mimetype,
2264 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2268 /* SigPattern */ bmp_sig_pattern,
2269 /* SigMask */ bmp_sig_mask,
2276 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2277 /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2278 /* CodecName */ jpeg_codecname,
2280 /* FormatDescription */ jpeg_format,
2281 /* FilenameExtension */ jpeg_extension,
2282 /* MimeType */ jpeg_mimetype,
2283 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2287 /* SigPattern */ jpeg_sig_pattern,
2288 /* SigMask */ jpeg_sig_mask,
2295 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2296 /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2297 /* CodecName */ gif_codecname,
2299 /* FormatDescription */ gif_format,
2300 /* FilenameExtension */ gif_extension,
2301 /* MimeType */ gif_mimetype,
2302 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2306 /* SigPattern */ gif_sig_pattern,
2307 /* SigMask */ gif_sig_mask,
2314 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2315 /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2316 /* CodecName */ emf_codecname,
2318 /* FormatDescription */ emf_format,
2319 /* FilenameExtension */ emf_extension,
2320 /* MimeType */ emf_mimetype,
2321 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2325 /* SigPattern */ emf_sig_pattern,
2326 /* SigMask */ emf_sig_mask,
2329 decode_image_olepicture_metafile
2333 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2334 /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2335 /* CodecName */ wmf_codecname,
2337 /* FormatDescription */ wmf_format,
2338 /* FilenameExtension */ wmf_extension,
2339 /* MimeType */ wmf_mimetype,
2340 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
2344 /* SigPattern */ wmf_sig_pattern,
2345 /* SigMask */ wmf_sig_mask,
2348 decode_image_olepicture_metafile
2352 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2353 /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2354 /* CodecName */ png_codecname,
2356 /* FormatDescription */ png_format,
2357 /* FilenameExtension */ png_extension,
2358 /* MimeType */ png_mimetype,
2359 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2363 /* SigPattern */ png_sig_pattern,
2364 /* SigMask */ png_sig_mask,
2371 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2372 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2373 /* CodecName */ ico_codecname,
2375 /* FormatDescription */ ico_format,
2376 /* FilenameExtension */ ico_extension,
2377 /* MimeType */ ico_mimetype,
2378 /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
2382 /* SigPattern */ ico_sig_pattern,
2383 /* SigMask */ ico_sig_mask,
2390 /*****************************************************************************
2391 * GdipGetImageDecodersSize [GDIPLUS.@]
2393 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
2395 int decoder_count=0;
2397 TRACE("%p %p\n", numDecoders, size);
2399 if (!numDecoders || !size)
2400 return InvalidParameter;
2402 for (i=0; i<NUM_CODECS; i++)
2404 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2408 *numDecoders = decoder_count;
2409 *size = decoder_count * sizeof(ImageCodecInfo);
2414 /*****************************************************************************
2415 * GdipGetImageDecoders [GDIPLUS.@]
2417 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
2419 int i, decoder_count=0;
2420 TRACE("%u %u %p\n", numDecoders, size, decoders);
2423 size != numDecoders * sizeof(ImageCodecInfo))
2424 return GenericError;
2426 for (i=0; i<NUM_CODECS; i++)
2428 if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
2430 if (decoder_count == numDecoders) return GenericError;
2431 memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2436 if (decoder_count < numDecoders) return GenericError;
2441 /*****************************************************************************
2442 * GdipGetImageEncodersSize [GDIPLUS.@]
2444 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
2446 int encoder_count=0;
2448 TRACE("%p %p\n", numEncoders, size);
2450 if (!numEncoders || !size)
2451 return InvalidParameter;
2453 for (i=0; i<NUM_CODECS; i++)
2455 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2459 *numEncoders = encoder_count;
2460 *size = encoder_count * sizeof(ImageCodecInfo);
2465 /*****************************************************************************
2466 * GdipGetImageEncoders [GDIPLUS.@]
2468 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
2470 int i, encoder_count=0;
2471 TRACE("%u %u %p\n", numEncoders, size, encoders);
2474 size != numEncoders * sizeof(ImageCodecInfo))
2475 return GenericError;
2477 for (i=0; i<NUM_CODECS; i++)
2479 if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
2481 if (encoder_count == numEncoders) return GenericError;
2482 memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
2487 if (encoder_count < numEncoders) return GenericError;
2492 /*****************************************************************************
2493 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
2495 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
2502 TRACE("%p %p %p\n", hbm, hpal, bitmap);
2505 return InvalidParameter;
2507 /* TODO: Support for device-dependent bitmaps */
2509 FIXME("no support for device-dependent bitmaps\n");
2510 return NotImplemented;
2513 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
2514 return InvalidParameter;
2516 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
2517 switch(bm.bmBitsPixel) {
2519 format = PixelFormat1bppIndexed;
2522 format = PixelFormat4bppIndexed;
2525 format = PixelFormat8bppIndexed;
2528 format = PixelFormat24bppRGB;
2531 format = PixelFormat32bppRGB;
2534 format = PixelFormat48bppRGB;
2537 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
2538 return InvalidParameter;
2542 bits = (BYTE*)bm.bmBits + (bm.bmHeight - 1) * bm.bmWidthBytes;
2545 FIXME("can only get image data from DIB sections\n");
2549 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, -bm.bmWidthBytes,
2550 format, bits, bitmap);
2555 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
2557 FIXME("(%p): stub\n", effect);
2558 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
2559 * in Windows's gdiplus */
2560 return NotImplemented;
2563 /*****************************************************************************
2564 * GdipSetEffectParameters [GDIPLUS.@]
2566 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
2567 const VOID *params, const UINT size)
2572 FIXME("not implemented\n");
2574 return NotImplemented;
2577 /*****************************************************************************
2578 * GdipGetImageFlags [GDIPLUS.@]
2580 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
2582 TRACE("%p %p\n", image, flags);
2584 if(!image || !flags)
2585 return InvalidParameter;
2587 *flags = image->flags;
2592 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
2594 TRACE("(%d, %p)\n", control, param);
2597 case TestControlForceBilinear:
2599 FIXME("TestControlForceBilinear not handled\n");
2601 case TestControlNoICM:
2603 FIXME("TestControlNoICM not handled\n");
2605 case TestControlGetBuildNumber:
2606 *((DWORD*)param) = 3102;
2613 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
2614 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
2615 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
2616 GpMetafile **metafile)
2618 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2619 frameUnit, debugstr_w(desc), metafile);
2621 return NotImplemented;
2624 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
2625 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
2626 GDIPCONST WCHAR *desc, GpMetafile **metafile)
2628 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
2629 frameUnit, debugstr_w(desc), metafile);
2631 return NotImplemented;
2634 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
2636 FIXME("%p\n", image);
2641 /*****************************************************************************
2642 * GdipGetImageThumbnail [GDIPLUS.@]
2644 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
2645 GpImage **ret_image, GetThumbnailImageAbort cb,
2648 FIXME("(%p %u %u %p %p %p) stub\n",
2649 image, width, height, ret_image, cb, cb_data);
2650 return NotImplemented;
2653 /*****************************************************************************
2654 * GdipImageRotateFlip [GDIPLUS.@]
2656 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
2658 FIXME("(%p %u) stub\n", image, type);
2659 return NotImplemented;