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
32 #include "gdiplus_private.h"
33 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
37 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
39 static INT ipicture_pixel_height(IPicture *pic)
44 IPicture_get_Height(pic, &y);
48 y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
54 static INT ipicture_pixel_width(IPicture *pic)
59 IPicture_get_Width(pic, &x);
63 x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
70 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
74 TRACE("%p %d %d %p\n", bitmap, x, y, color);
77 return InvalidParameter;
80 FIXME("not implemented\n");
84 return NotImplemented;
87 /* This function returns a pointer to an array of pixels that represents the
88 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
89 * flags. It is correct behavior that a user who calls this function with write
90 * privileges can write to the whole bitmap (not just the area in rect).
92 * FIXME: only used portion of format is bits per pixel. */
93 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
94 UINT flags, PixelFormat format, BitmapData* lockeddata)
97 INT stride, bitspp = PIXELFORMATBPP(format);
104 GpRect act_rect; /* actual rect to be used */
106 TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
108 if(!lockeddata || !bitmap)
109 return InvalidParameter;
112 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
113 (rect->Y + rect->Height > bitmap->height) || !flags)
114 return InvalidParameter;
119 act_rect.X = act_rect.Y = 0;
120 act_rect.Width = bitmap->width;
121 act_rect.Height = bitmap->height;
124 if(flags & ImageLockModeUserInputBuf)
125 return NotImplemented;
130 IPicture_get_Handle(bitmap->image.picture, &hbm);
131 IPicture_get_CurDC(bitmap->image.picture, &hdc);
132 bm_is_selected = (hdc != 0);
134 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
137 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
138 pbmi->bmiHeader.biBitCount = 0;
141 hdc = CreateCompatibleDC(0);
142 old = SelectObject(hdc, (HBITMAP)hbm);
146 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
148 abs_height = abs(pbmi->bmiHeader.biHeight);
149 stride = pbmi->bmiHeader.biWidth * bitspp / 8;
150 stride = (stride + 3) & ~3;
152 buff = GdipAlloc(stride * abs_height);
154 pbmi->bmiHeader.biBitCount = bitspp;
157 GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
160 SelectObject(hdc, old);
169 lockeddata->Width = act_rect.Width;
170 lockeddata->Height = act_rect.Height;
171 lockeddata->PixelFormat = format;
172 lockeddata->Reserved = flags;
174 if(pbmi->bmiHeader.biHeight > 0){
175 lockeddata->Stride = -stride;
176 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X +
177 stride * (abs_height - 1 - act_rect.Y);
180 lockeddata->Stride = stride;
181 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
184 bitmap->lockmode = flags;
187 bitmap->bitmapbits = buff;
193 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
194 BitmapData* lockeddata)
202 if(!bitmap || !lockeddata)
203 return InvalidParameter;
205 if(!bitmap->lockmode)
208 if(lockeddata->Reserved & ImageLockModeUserInputBuf)
209 return NotImplemented;
211 if(lockeddata->Reserved & ImageLockModeRead){
212 if(!(--bitmap->numlocks))
213 bitmap->lockmode = 0;
215 GdipFree(bitmap->bitmapbits);
216 bitmap->bitmapbits = NULL;
220 IPicture_get_Handle(bitmap->image.picture, &hbm);
221 IPicture_get_CurDC(bitmap->image.picture, &hdc);
222 bm_is_selected = (hdc != 0);
224 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
225 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
226 pbmi->bmiHeader.biBitCount = 0;
229 hdc = CreateCompatibleDC(0);
230 old = SelectObject(hdc, (HBITMAP)hbm);
233 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
234 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
235 SetDIBits(hdc, (HBITMAP)hbm, 0, abs(pbmi->bmiHeader.biHeight),
236 bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
239 SelectObject(hdc, old);
244 GdipFree(bitmap->bitmapbits);
245 bitmap->bitmapbits = NULL;
246 bitmap->lockmode = 0;
251 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
257 GpStatus stat = GenericError;
259 TRACE("%p, %p\n", image, cloneImage);
261 if (!image || !cloneImage)
262 return InvalidParameter;
264 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
268 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
271 WARN("Failed to save image on stream\n");
275 /* Set seek pointer back to the beginning of the picture */
277 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
281 stat = GdipLoadImageFromStream(stream, cloneImage);
282 if (stat != Ok) WARN("Failed to load image from stream\n");
285 IStream_Release(stream);
289 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
295 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
297 if(!filename || !bitmap)
298 return InvalidParameter;
300 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
305 stat = GdipCreateBitmapFromStream(stream, bitmap);
307 IStream_Release(stream);
312 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
313 VOID *bits, GpBitmap **bitmap)
315 DWORD height, stride;
318 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
320 height = abs(info->bmiHeader.biHeight);
321 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
323 if(info->bmiHeader.biHeight > 0) /* bottom-up */
325 bits = (BYTE*)bits + (height - 1) * stride;
329 switch(info->bmiHeader.biBitCount) {
331 format = PixelFormat1bppIndexed;
334 format = PixelFormat4bppIndexed;
337 format = PixelFormat8bppIndexed;
340 format = PixelFormat24bppRGB;
343 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
345 return InvalidParameter;
348 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
354 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
357 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
359 return GdipCreateBitmapFromFile(filename, bitmap);
362 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
363 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
366 GpStatus stat = InvalidParameter;
368 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
370 if(!lpBitmapName || !bitmap)
371 return InvalidParameter;
374 hbm = (HBITMAP)LoadImageW(hInstance,lpBitmapName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);
377 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
384 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
385 HBITMAP* hbmReturn, ARGB background)
391 return NotImplemented;
394 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
395 GpMetafile* metafile, BOOL* succ, EmfType emfType,
396 const WCHAR* description, GpMetafile** out_metafile)
400 if(!ref || !metafile || !out_metafile)
401 return InvalidParameter;
404 *out_metafile = NULL;
407 FIXME("not implemented\n");
409 return NotImplemented;
412 /* FIXME: this should create a bitmap in the given size with the attributes
413 * (resolution etc.) of the graphics object */
414 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
415 GpGraphics* target, GpBitmap** bitmap)
420 if(!target || !bitmap)
421 return InvalidParameter;
424 FIXME("hacked stub\n");
426 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
432 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
433 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
435 BITMAPFILEHEADER *bmfh;
436 BITMAPINFOHEADER *bmih;
441 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
443 if (!bitmap) return InvalidParameter;
445 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
447 return InvalidParameter;
451 return InvalidParameter;
453 /* FIXME: windows allows negative stride (reads backwards from scan0) */
455 FIXME("negative stride\n");
456 return InvalidParameter;
459 *bitmap = GdipAlloc(sizeof(GpBitmap));
460 if(!*bitmap) return OutOfMemory;
463 stride = width * (PIXELFORMATBPP(format) / 8);
464 stride = (stride + 3) & ~3;
467 datalen = abs(stride * height);
468 size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
469 buff = GdipAlloc(size);
475 bmfh = (BITMAPFILEHEADER*) buff;
476 bmih = (BITMAPINFOHEADER*) (bmfh + 1);
478 bmfh->bfType = (((WORD)'M') << 8) + (WORD)'B';
480 bmfh->bfOffBits = size - datalen;
482 bmih->biSize = sizeof(BITMAPINFOHEADER);
483 bmih->biWidth = width;
484 bmih->biHeight = -height;
485 /* FIXME: use the rest of the data from format */
486 bmih->biBitCount = PIXELFORMATBPP(format);
487 bmih->biCompression = BI_RGB;
488 bmih->biSizeImage = datalen;
491 memcpy(bmih + 1, scan0, datalen);
493 memset(bmih + 1, 0, datalen);
495 if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
496 ERR("could not make stream\n");
502 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
503 (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
504 TRACE("Could not load picture\n");
505 IStream_Release(stream);
511 (*bitmap)->image.type = ImageTypeBitmap;
512 (*bitmap)->image.flags = ImageFlagsNone;
513 (*bitmap)->width = width;
514 (*bitmap)->height = height;
515 (*bitmap)->format = format;
520 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
525 TRACE("%p %p\n", stream, bitmap);
527 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
532 if((*bitmap)->image.type != ImageTypeBitmap){
533 IPicture_Release((*bitmap)->image.picture);
535 return GenericError; /* FIXME: what error to return? */
542 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
545 TRACE("%p %p\n", stream, bitmap);
547 return GdipCreateBitmapFromStream(stream, bitmap);
550 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
551 GpCachedBitmap **cachedbmp)
556 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
558 if(!bitmap || !graphics || !cachedbmp)
559 return InvalidParameter;
561 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
564 (*cachedbmp)->bmp = GdipAlloc(sizeof(GpBitmap));
565 if(!(*cachedbmp)->bmp){
566 GdipFree(*cachedbmp);
570 copy = &(*cachedbmp)->bmp->image;
571 stat = GdipCloneImage(&(bitmap->image), ©);
573 GdipFree(*cachedbmp);
577 (*cachedbmp)->bmp->width = bitmap->width;
578 (*cachedbmp)->bmp->height = bitmap->height;
579 (*cachedbmp)->bmp->format = bitmap->format;
580 (*cachedbmp)->bmp->lockmode = 0;
581 (*cachedbmp)->bmp->numlocks = 0;
582 (*cachedbmp)->bmp->bitmapbits = NULL;
587 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
589 TRACE("%p\n", cachedbmp);
592 return InvalidParameter;
594 GdipDisposeImage(&cachedbmp->bmp->image);
595 GdipFree(cachedbmp->bmp);
600 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
601 GpCachedBitmap *cachedbmp, INT x, INT y)
603 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
605 if(!graphics || !cachedbmp)
606 return InvalidParameter;
608 return GdipDrawImage(graphics, &cachedbmp->bmp->image, (REAL)x, (REAL)y);
611 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
615 TRACE("%p\n", image);
618 return InvalidParameter;
620 IPicture_get_CurDC(image->picture, &hdc);
622 IPicture_Release(image->picture);
623 if (image->type == ImageTypeBitmap)
624 GdipFree(((GpBitmap*)image)->bitmapbits);
630 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
633 return InvalidParameter;
635 return NotImplemented;
638 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
641 TRACE("%p %p %p\n", image, srcRect, srcUnit);
643 if(!image || !srcRect || !srcUnit)
644 return InvalidParameter;
645 if(image->type == ImageTypeMetafile){
646 *srcRect = ((GpMetafile*)image)->bounds;
647 *srcUnit = ((GpMetafile*)image)->unit;
649 else if(image->type == ImageTypeBitmap){
650 srcRect->X = srcRect->Y = 0.0;
651 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
652 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
653 *srcUnit = UnitPixel;
656 srcRect->X = srcRect->Y = 0.0;
657 srcRect->Width = ipicture_pixel_width(image->picture);
658 srcRect->Height = ipicture_pixel_height(image->picture);
659 *srcUnit = UnitPixel;
662 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
663 srcRect->Width, srcRect->Height, *srcUnit);
668 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
671 TRACE("%p %p %p\n", image, width, height);
673 if(!image || !height || !width)
674 return InvalidParameter;
676 if(image->type == ImageTypeMetafile){
679 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
680 ((GpMetafile*)image)->bounds.Height;
682 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
683 ((GpMetafile*)image)->bounds.Width;
688 else if(image->type == ImageTypeBitmap){
689 *height = ((GpBitmap*)image)->height;
690 *width = ((GpBitmap*)image)->width;
693 *height = ipicture_pixel_height(image->picture);
694 *width = ipicture_pixel_width(image->picture);
697 TRACE("returning (%f, %f)\n", *height, *width);
701 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
702 GpGraphics **graphics)
706 TRACE("%p %p\n", image, graphics);
708 if(!image || !graphics)
709 return InvalidParameter;
711 if(image->type != ImageTypeBitmap){
712 FIXME("not implemented for image type %d\n", image->type);
713 return NotImplemented;
716 IPicture_get_CurDC(image->picture, &hdc);
719 hdc = CreateCompatibleDC(0);
720 IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
723 return GdipCreateFromHDC(hdc, graphics);
726 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
728 TRACE("%p %p\n", image, height);
730 if(!image || !height)
731 return InvalidParameter;
733 if(image->type == ImageTypeMetafile){
736 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
737 ((GpMetafile*)image)->bounds.Height);
741 else if(image->type == ImageTypeBitmap)
742 *height = ((GpBitmap*)image)->height;
744 *height = ipicture_pixel_height(image->picture);
746 TRACE("returning %d\n", *height);
751 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
756 return InvalidParameter;
759 FIXME("not implemented\n");
761 return NotImplemented;
764 /* FIXME: test this function for non-bitmap types */
765 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
767 TRACE("%p %p\n", image, format);
769 if(!image || !format)
770 return InvalidParameter;
772 if(image->type != ImageTypeBitmap)
773 *format = PixelFormat24bppRGB;
775 *format = ((GpBitmap*) image)->format;
780 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
784 if(!image || !format)
785 return InvalidParameter;
788 FIXME("not implemented\n");
790 return NotImplemented;
793 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
795 TRACE("%p %p\n", image, type);
798 return InvalidParameter;
805 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
810 return InvalidParameter;
813 FIXME("not implemented\n");
815 return NotImplemented;
818 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
820 TRACE("%p %p\n", image, width);
823 return InvalidParameter;
825 if(image->type == ImageTypeMetafile){
828 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
829 ((GpMetafile*)image)->bounds.Width);
833 else if(image->type == ImageTypeBitmap)
834 *width = ((GpBitmap*)image)->width;
836 *width = ipicture_pixel_width(image->picture);
838 TRACE("returning %d\n", *width);
843 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
844 MetafileHeader * header)
848 if(!metafile || !header)
849 return InvalidParameter;
852 FIXME("not implemented\n");
857 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
858 UINT num, PropertyItem* items)
863 FIXME("not implemented\n");
865 return InvalidParameter;
868 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
873 FIXME("not implemented\n");
875 return InvalidParameter;
878 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
883 FIXME("not implemented\n");
885 return InvalidParameter;
888 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
889 PropertyItem* buffer)
894 FIXME("not implemented\n");
896 return InvalidParameter;
899 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
904 TRACE("%p %x %p\n", image, pid, size);
907 return InvalidParameter;
910 FIXME("not implemented\n");
912 return NotImplemented;
915 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
920 FIXME("not implemented\n");
922 return InvalidParameter;
925 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
926 GDIPCONST GUID* dimensionID, UINT* count)
930 if(!image || !dimensionID || !count)
931 return InvalidParameter;
934 FIXME("not implemented\n");
936 return NotImplemented;
939 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
943 return InvalidParameter;
952 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
953 GUID* dimensionIDs, UINT count)
957 if(!image || !dimensionIDs)
958 return InvalidParameter;
961 FIXME("not implemented\n");
966 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
967 GDIPCONST GUID* dimensionID, UINT frameidx)
971 if(!image || !dimensionID)
972 return InvalidParameter;
975 FIXME("not implemented\n");
980 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
986 TRACE("(%s) %p\n", debugstr_w(filename), image);
988 if (!filename || !image)
989 return InvalidParameter;
991 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
996 stat = GdipLoadImageFromStream(stream, image);
998 IStream_Release(stream);
1003 /* FIXME: no icm handling */
1004 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1006 TRACE("(%s) %p\n", debugstr_w(filename), image);
1008 return GdipLoadImageFromFile(filename, image);
1011 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1016 TRACE("%p %p\n", stream, image);
1018 if(!stream || !image)
1019 return InvalidParameter;
1021 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1022 (LPVOID*) &pic) != S_OK){
1023 TRACE("Could not load picture\n");
1024 return GenericError;
1027 IPicture_get_Type(pic, &type);
1029 if(type == PICTYPE_BITMAP){
1031 BITMAPCOREHEADER* bmch;
1035 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1038 *image = GdipAlloc(sizeof(GpBitmap));
1043 (*image)->type = ImageTypeBitmap;
1045 (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
1046 (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
1048 /* get the pixel format */
1049 IPicture_get_Handle(pic, &hbm);
1050 IPicture_get_CurDC(pic, &hdc);
1052 bmch = (BITMAPCOREHEADER*) (&pbmi->bmiHeader);
1053 bmch->bcSize = sizeof(BITMAPCOREHEADER);
1057 hdc = CreateCompatibleDC(0);
1058 old = SelectObject(hdc, (HBITMAP)hbm);
1059 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1060 SelectObject(hdc, old);
1064 GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1066 (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
1069 else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
1070 /* FIXME: missing initialization code */
1071 *image = GdipAlloc(sizeof(GpMetafile));
1072 if(!*image) return OutOfMemory;
1073 (*image)->type = ImageTypeMetafile;
1076 *image = GdipAlloc(sizeof(GpImage));
1077 if(!*image) return OutOfMemory;
1078 (*image)->type = ImageTypeUnknown;
1081 (*image)->picture = pic;
1082 (*image)->flags = ImageFlagsNone;
1088 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1090 TRACE("%p %p\n", stream, image);
1092 return GdipLoadImageFromStream(stream, image);
1095 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1100 return InvalidParameter;
1103 FIXME("not implemented\n");
1105 return NotImplemented;
1108 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1113 FIXME("not implemented\n");
1115 return NotImplemented;
1118 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1119 GDIPCONST CLSID *clsidEncoder,
1120 GDIPCONST EncoderParameters *encoderParams)
1125 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1127 if (!image || !filename|| !clsidEncoder)
1128 return InvalidParameter;
1130 if (!(image->picture))
1131 return InvalidParameter;
1133 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1135 return GenericError;
1137 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1139 IStream_Release(stream);
1143 /*************************************************************************
1144 * Encoding functions -
1145 * These functions encode an image in different image file formats.
1147 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1148 #define BITMAP_FORMAT_JPEG 0xd8ff
1149 #define BITMAP_FORMAT_GIF 0x4947
1150 #define BITMAP_FORMAT_PNG 0x5089
1151 #define BITMAP_FORMAT_APM 0xcdd7
1153 static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1154 void **output, unsigned int *output_size)
1156 int num_palette_entries;
1157 BITMAPFILEHEADER *bmp_file_hdr;
1158 BITMAPINFO *bmp_info_hdr;
1160 if (bitmap_info->bmiHeader.biClrUsed) {
1161 num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
1162 if (num_palette_entries > 256) num_palette_entries = 256;
1164 if (bitmap_info->bmiHeader.biBitCount <= 8)
1165 num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
1167 num_palette_entries = 0;
1171 sizeof(BITMAPFILEHEADER) +
1172 sizeof(BITMAPINFOHEADER) +
1173 num_palette_entries * sizeof(RGBQUAD) +
1174 bitmap_info->bmiHeader.biSizeImage;
1176 *output = GdipAlloc(*output_size);
1178 bmp_file_hdr = (BITMAPFILEHEADER*) *output;
1179 bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
1180 bmp_file_hdr->bfSize = *output_size;
1181 bmp_file_hdr->bfOffBits =
1182 sizeof(BITMAPFILEHEADER) +
1183 sizeof(BITMAPINFOHEADER) +
1184 num_palette_entries * sizeof (RGBQUAD);
1186 bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
1187 memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
1188 memcpy((unsigned char *)(*output) +
1189 sizeof(BITMAPFILEHEADER) +
1190 sizeof(BITMAPINFOHEADER) +
1191 num_palette_entries * sizeof(RGBQUAD),
1192 bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
1197 typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1198 void **output, unsigned int *output_size);
1202 NUM_ENCODERS_SUPPORTED
1205 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
1206 static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
1210 /*****************************************************************************
1211 * GdipSaveImageToStream [GDIPLUS.@]
1213 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
1214 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1223 BITMAPINFO bmp_info;
1225 encode_image_func* encode_image;
1227 unsigned int output_size;
1235 TRACE("%p %p %p %p\n", image, stream, clsid, params);
1237 if(!image || !stream)
1238 return InvalidParameter;
1240 if (!image->picture)
1241 return GenericError;
1243 hr = IPicture_get_Type(image->picture, &type);
1244 if (FAILED(hr) || type != PICTYPE_BITMAP)
1245 return GenericError;
1247 /* select correct encoder */
1248 encode_image = NULL;
1249 for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
1250 if (IsEqualCLSID(clsid, &codecs[i].Clsid))
1251 encode_image = encode_image_funcs[i];
1253 if (encode_image == NULL)
1254 return UnknownImageFormat;
1256 /* extract underlying hbitmap representation from the IPicture */
1257 hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
1258 if (FAILED(hr) || !hbmp)
1259 return GenericError;
1260 hr = IPicture_get_CurDC(image->picture, &hdc);
1262 return GenericError;
1263 bm_is_selected = (hdc != 0);
1264 if (!bm_is_selected) {
1265 hdc = CreateCompatibleDC(0);
1266 old_hbmp = SelectObject(hdc, hbmp);
1269 /* get bits from HBITMAP */
1270 bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
1271 bmp_info.bmiHeader.biBitCount = 0;
1272 GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
1274 bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
1277 GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
1279 if (!bm_is_selected) {
1280 SelectObject(hdc, old_hbmp);
1287 stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
1289 IStream_Write(stream, output, output_size, &dummy);
1297 /*****************************************************************************
1298 * GdipSetImagePalette [GDIPLUS.@]
1300 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
1301 GDIPCONST ColorPalette *palette)
1305 if(!image || !palette)
1306 return InvalidParameter;
1309 FIXME("not implemented\n");
1311 return NotImplemented;
1314 /*************************************************************************
1316 * Structures that represent which formats we support for encoding.
1319 /* ImageCodecInfo creation routines taken from libgdiplus */
1320 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1321 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1322 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1323 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1324 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1325 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1327 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
1330 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
1331 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
1332 /* CodecName */ bmp_codecname,
1334 /* FormatDescription */ bmp_format,
1335 /* FilenameExtension */ bmp_extension,
1336 /* MimeType */ bmp_mimetype,
1337 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
1341 /* SigPattern */ bmp_sig_pattern,
1342 /* SigMask */ bmp_sig_mask,
1346 /*****************************************************************************
1347 * GdipGetImageDecodersSize [GDIPLUS.@]
1349 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
1351 FIXME("%p %p stub!\n", numDecoders, size);
1353 if (!numDecoders || !size)
1354 return InvalidParameter;
1362 /*****************************************************************************
1363 * GdipGetImageDecoders [GDIPLUS.@]
1365 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
1367 FIXME("%u %u %p stub!\n", numDecoders, size, decoders);
1370 return GenericError;
1372 return NotImplemented;
1375 /*****************************************************************************
1376 * GdipGetImageEncodersSize [GDIPLUS.@]
1378 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
1380 TRACE("%p %p\n", numEncoders, size);
1382 if (!numEncoders || !size)
1383 return InvalidParameter;
1385 *numEncoders = NUM_ENCODERS_SUPPORTED;
1386 *size = sizeof (codecs);
1391 /*****************************************************************************
1392 * GdipGetImageEncoders [GDIPLUS.@]
1394 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
1396 TRACE("%u %u %p\n", numEncoders, size, encoders);
1399 (numEncoders != NUM_ENCODERS_SUPPORTED) ||
1400 (size != sizeof (codecs)))
1401 return GenericError;
1403 memcpy(encoders, codecs, sizeof (codecs));
1408 /*****************************************************************************
1409 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
1411 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
1417 TRACE("%p %p %p\n", hbm, hpal, bitmap);
1420 return InvalidParameter;
1422 /* TODO: Support for device-dependent bitmaps */
1424 FIXME("no support for device-dependent bitmaps\n");
1425 return NotImplemented;
1428 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
1429 return InvalidParameter;
1431 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
1432 switch(bm.bmBitsPixel) {
1434 format = PixelFormat1bppIndexed;
1437 format = PixelFormat4bppIndexed;
1440 format = PixelFormat8bppIndexed;
1443 format = PixelFormat24bppRGB;
1446 format = PixelFormat32bppRGB;
1449 format = PixelFormat48bppRGB;
1452 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
1453 return InvalidParameter;
1456 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
1457 format, bm.bmBits, bitmap);
1462 /*****************************************************************************
1463 * GdipSetEffectParameters [GDIPLUS.@]
1465 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
1466 const VOID *params, const UINT size)
1471 FIXME("not implemented\n");
1473 return NotImplemented;
1476 /*****************************************************************************
1477 * GdipGetImageFlags [GDIPLUS.@]
1479 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
1481 TRACE("%p %p\n", image, flags);
1483 if(!image || !flags)
1484 return InvalidParameter;
1486 *flags = image->flags;
1491 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
1493 TRACE("(%d, %p)\n", control, param);
1496 case TestControlForceBilinear:
1498 FIXME("TestControlForceBilinear not handled\n");
1500 case TestControlNoICM:
1502 FIXME("TestControlNoICM not handled\n");
1504 case TestControlGetBuildNumber:
1505 *((DWORD*)param) = 3102;
1512 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
1513 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
1514 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
1515 GpMetafile **metafile)
1517 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1518 frameUnit, debugstr_w(desc), metafile);
1520 return NotImplemented;
1523 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
1524 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
1525 GDIPCONST WCHAR *desc, GpMetafile **metafile)
1527 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1528 frameUnit, debugstr_w(desc), metafile);
1530 return NotImplemented;