#include <stdarg.h>
+#define NONAMELESSUNION
+
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "olectl.h"
#include "ole2.h"
+#include "initguid.h"
+#include "wincodec.h"
#include "gdiplus.h"
#include "gdiplus_private.h"
#include "wine/debug.h"
return x;
}
+GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
+ RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
+{
+ FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
+ /*
+ * Note: According to Jose Roca's GDI+ docs, this function is not
+ * implemented in Windows's GDI+.
+ */
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
+ INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
+ GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
+{
+ FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
+ /*
+ * Note: According to Jose Roca's GDI+ docs, this function is not
+ * implemented in Windows's GDI+.
+ */
+ return NotImplemented;
+}
+
+static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = *g = *b = row[x*2+1];
+ *a = 255;
+}
+
+static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ WORD pixel = *((WORD*)(row)+x);
+ *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
+ *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
+ *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
+ *a = 255;
+}
+
+static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ WORD pixel = *((WORD*)(row)+x);
+ *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
+ *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
+ *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
+ *a = 255;
+}
+
+static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ WORD pixel = *((WORD*)(row)+x);
+ *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
+ *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
+ *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
+ if ((pixel&0x8000) == 0x8000)
+ *a = 255;
+ else
+ *a = 0;
+}
+
+static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = row[x*3+2];
+ *g = row[x*3+1];
+ *b = row[x*3];
+ *a = 255;
+}
+
+static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = row[x*4+2];
+ *g = row[x*4+1];
+ *b = row[x*4];
+ *a = 255;
+}
+
+static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = row[x*4+2];
+ *g = row[x*4+1];
+ *b = row[x*4];
+ *a = row[x*4+3];
+}
+
+static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *a = row[x*4+3];
+ if (*a == 0)
+ *r = *g = *b = 0;
+ else
+ {
+ *r = row[x*4+2] * 255 / *a;
+ *g = row[x*4+1] * 255 / *a;
+ *b = row[x*4] * 255 / *a;
+ }
+}
+
+static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = row[x*6+5];
+ *g = row[x*6+3];
+ *b = row[x*6+1];
+ *a = 255;
+}
+
+static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *r = row[x*8+5];
+ *g = row[x*8+3];
+ *b = row[x*8+1];
+ *a = row[x*8+7];
+}
+
+static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
+ const BYTE *row, UINT x)
+{
+ *a = row[x*8+7];
+ if (*a == 0)
+ *r = *g = *b = 0;
+ else
+ {
+ *r = row[x*8+5] * 255 / *a;
+ *g = row[x*8+3] * 255 / *a;
+ *b = row[x*8+1] * 255 / *a;
+ }
+}
+
GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
ARGB *color)
{
- static int calls;
+ BYTE r, g, b, a;
+ BYTE *row;
TRACE("%p %d %d %p\n", bitmap, x, y, color);
- if(!bitmap || !color)
+ if(!bitmap || !color ||
+ x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
return InvalidParameter;
- if(!(calls++))
- FIXME("not implemented\n");
+ row = bitmap->bits+bitmap->stride*y;
+
+ switch (bitmap->format)
+ {
+ case PixelFormat16bppGrayScale:
+ getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat16bppRGB555:
+ getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat16bppRGB565:
+ getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat16bppARGB1555:
+ getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat24bppRGB:
+ getpixel_24bppRGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat32bppRGB:
+ getpixel_32bppRGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat32bppARGB:
+ getpixel_32bppARGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat32bppPARGB:
+ getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat48bppRGB:
+ getpixel_48bppRGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat64bppARGB:
+ getpixel_64bppARGB(&r,&g,&b,&a,row,x);
+ break;
+ case PixelFormat64bppPARGB:
+ getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
+ break;
+ default:
+ FIXME("not implemented for format 0x%x\n", bitmap->format);
+ return NotImplemented;
+}
+
+ *color = a<<24|r<<16|g<<8|b;
+
+ return Ok;
+}
+
+static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((WORD*)(row)+x) = (r+g+b)*85;
+}
+
+static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((WORD*)(row)+x) = (r<<7&0x7c00)|
+ (g<<2&0x03e0)|
+ (b>>3&0x001f);
+}
+
+static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((WORD*)(row)+x) = (r<<8&0xf800)|
+ (g<<3&0x07e0)|
+ (b>>3&0x001f);
+}
+
+static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((WORD*)(row)+x) = (a<<8&0x8000)|
+ (r<<7&0x7c00)|
+ (g<<2&0x03e0)|
+ (b>>3&0x001f);
+}
+
+static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ row[x*3+2] = r;
+ row[x*3+1] = g;
+ row[x*3] = b;
+}
+
+static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
+}
+
+static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
+}
+
+static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ r = r * a / 255;
+ g = g * a / 255;
+ b = b * a / 255;
+ *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
+}
- *color = 0xdeadbeef;
+static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ row[x*6+5] = row[x*6+4] = r;
+ row[x*6+3] = row[x*6+2] = g;
+ row[x*6+1] = row[x*6] = b;
+}
+
+static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ UINT64 a64=a, r64=r, g64=g, b64=b;
+ *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
+}
+
+static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
+ BYTE *row, UINT x)
+{
+ UINT64 a64, r64, g64, b64;
+ a64 = a * 257;
+ r64 = r * a / 255;
+ g64 = g * a / 255;
+ b64 = b * a / 255;
+ *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
+}
+GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
+ ARGB color)
+{
+ BYTE a, r, g, b;
+ BYTE *row;
+ TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap, x, y, color);
+
+ if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
+ return InvalidParameter;
+
+ a = color>>24;
+ r = color>>16;
+ g = color>>8;
+ b = color;
+
+ row = bitmap->bits + bitmap->stride * y;
+
+ switch (bitmap->format)
+ {
+ case PixelFormat16bppGrayScale:
+ setpixel_16bppGrayScale(r,g,b,a,row,x);
+ break;
+ case PixelFormat16bppRGB555:
+ setpixel_16bppRGB555(r,g,b,a,row,x);
+ break;
+ case PixelFormat16bppRGB565:
+ setpixel_16bppRGB565(r,g,b,a,row,x);
+ break;
+ case PixelFormat16bppARGB1555:
+ setpixel_16bppARGB1555(r,g,b,a,row,x);
+ break;
+ case PixelFormat24bppRGB:
+ setpixel_24bppRGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat32bppRGB:
+ setpixel_32bppRGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat32bppARGB:
+ setpixel_32bppARGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat32bppPARGB:
+ setpixel_32bppPARGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat48bppRGB:
+ setpixel_48bppRGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat64bppARGB:
+ setpixel_64bppARGB(r,g,b,a,row,x);
+ break;
+ case PixelFormat64bppPARGB:
+ setpixel_64bppPARGB(r,g,b,a,row,x);
+ break;
+ default:
+ FIXME("not implemented for format 0x%x\n", bitmap->format);
return NotImplemented;
}
+ return Ok;
+}
+
/* This function returns a pointer to an array of pixels that represents the
* bitmap. The *entire* bitmap is locked according to the lock mode specified by
* flags. It is correct behavior that a user who calls this function with write
{
BOOL bm_is_selected;
INT stride, bitspp = PIXELFORMATBPP(format);
- OLE_HANDLE hbm;
HDC hdc;
- HBITMAP old = NULL;
- BITMAPINFO bmi;
+ HBITMAP hbm, old = NULL;
+ BITMAPINFO *pbmi;
BYTE *buff = NULL;
UINT abs_height;
GpRect act_rect; /* actual rect to be used */
if(bitmap->lockmode)
return WrongState;
- IPicture_get_Handle(bitmap->image.picture, &hbm);
- IPicture_get_CurDC(bitmap->image.picture, &hdc);
+ if (bitmap->bits && bitmap->format == format)
+ {
+ /* no conversion is necessary; just use the bits directly */
+ lockeddata->Width = act_rect.Width;
+ lockeddata->Height = act_rect.Height;
+ lockeddata->PixelFormat = format;
+ lockeddata->Reserved = flags;
+ lockeddata->Stride = bitmap->stride;
+ lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
+ bitmap->stride * act_rect.Y;
+
+ bitmap->lockmode = flags;
+ bitmap->numlocks++;
+
+ return Ok;
+ }
+
+ hbm = bitmap->hbitmap;
+ hdc = bitmap->hdc;
bm_is_selected = (hdc != 0);
- bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- bmi.bmiHeader.biBitCount = 0;
+ pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+ if (!pbmi)
+ return OutOfMemory;
+ pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ pbmi->bmiHeader.biBitCount = 0;
if(!bm_is_selected){
hdc = CreateCompatibleDC(0);
- old = SelectObject(hdc, (HBITMAP)hbm);
+ old = SelectObject(hdc, hbm);
}
/* fill out bmi */
- GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
- abs_height = abs(bmi.bmiHeader.biHeight);
- stride = bmi.bmiHeader.biWidth * bitspp / 8;
+ abs_height = abs(pbmi->bmiHeader.biHeight);
+ stride = pbmi->bmiHeader.biWidth * bitspp / 8;
stride = (stride + 3) & ~3;
buff = GdipAlloc(stride * abs_height);
- bmi.bmiHeader.biBitCount = bitspp;
+ pbmi->bmiHeader.biBitCount = bitspp;
if(buff)
- GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, buff, &bmi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
if(!bm_is_selected){
SelectObject(hdc, old);
DeleteDC(hdc);
}
- if(!buff)
+ if(!buff){
+ GdipFree(pbmi);
return OutOfMemory;
+ }
lockeddata->Width = act_rect.Width;
lockeddata->Height = act_rect.Height;
lockeddata->PixelFormat = format;
lockeddata->Reserved = flags;
- if(bmi.bmiHeader.biHeight > 0){
+ if(pbmi->bmiHeader.biHeight > 0){
lockeddata->Stride = -stride;
lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X +
stride * (abs_height - 1 - act_rect.Y);
bitmap->bitmapbits = buff;
+ GdipFree(pbmi);
return Ok;
}
+GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
+{
+ FIXME("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
+
+ return NotImplemented;
+}
+
GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
BitmapData* lockeddata)
{
- OLE_HANDLE hbm;
HDC hdc;
- HBITMAP old = NULL;
+ HBITMAP hbm, old = NULL;
BOOL bm_is_selected;
- BITMAPINFO bmi;
+ BITMAPINFO *pbmi;
if(!bitmap || !lockeddata)
return InvalidParameter;
return Ok;
}
- IPicture_get_Handle(bitmap->image.picture, &hbm);
- IPicture_get_CurDC(bitmap->image.picture, &hdc);
+ if (!bitmap->bitmapbits)
+ {
+ /* we passed a direct reference; no need to do anything */
+ bitmap->lockmode = 0;
+ return Ok;
+ }
+
+ hbm = bitmap->hbitmap;
+ hdc = bitmap->hdc;
bm_is_selected = (hdc != 0);
- bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- bmi.bmiHeader.biBitCount = 0;
+ pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+ pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ pbmi->bmiHeader.biBitCount = 0;
if(!bm_is_selected){
hdc = CreateCompatibleDC(0);
- old = SelectObject(hdc, (HBITMAP)hbm);
+ old = SelectObject(hdc, hbm);
}
- GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
- bmi.bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
- SetDIBits(hdc, (HBITMAP)hbm, 0, abs(bmi.bmiHeader.biHeight),
- bitmap->bitmapbits, &bmi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
+ pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
+ SetDIBits(hdc, hbm, 0, abs(pbmi->bmiHeader.biHeight),
+ bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
if(!bm_is_selected){
SelectObject(hdc, old);
DeleteDC(hdc);
}
+ GdipFree(pbmi);
GdipFree(bitmap->bitmapbits);
bitmap->bitmapbits = NULL;
bitmap->lockmode = 0;
return Ok;
}
+GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
+ PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
+{
+ FIXME("(%f,%f,%f,%f,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
+ PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
+{
+ FIXME("(%i,%i,%i,%i,%i,%p,%p): stub\n", x, y, width, height, format, srcBitmap, dstBitmap);
+
+ return NotImplemented;
+}
+
GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
{
- IStream* stream;
- HRESULT hr;
- INT size;
+ GpStatus stat = GenericError;
TRACE("%p, %p\n", image, cloneImage);
if (!image || !cloneImage)
return InvalidParameter;
- hr = CreateStreamOnHGlobal(0, TRUE, &stream);
- if (FAILED(hr))
- return GenericError;
-
- *cloneImage = GdipAlloc(sizeof(GpImage));
- if (!*cloneImage)
+ if (image->picture)
{
+ IStream* stream;
+ HRESULT hr;
+ INT size;
+ LARGE_INTEGER move;
+
+ hr = CreateStreamOnHGlobal(0, TRUE, &stream);
+ if (FAILED(hr))
+ return GenericError;
+
+ hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
+ if(FAILED(hr))
+ {
+ WARN("Failed to save image on stream\n");
+ goto out;
+ }
+
+ /* Set seek pointer back to the beginning of the picture */
+ move.QuadPart = 0;
+ hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
+ if (FAILED(hr))
+ goto out;
+
+ stat = GdipLoadImageFromStream(stream, cloneImage);
+ if (stat != Ok) WARN("Failed to load image from stream\n");
+
+ out:
IStream_Release(stream);
- return OutOfMemory;
+ return stat;
}
- (*cloneImage)->type = image->type;
- (*cloneImage)->flags = image->flags;
-
- hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
- if(FAILED(hr))
+ else if (image->type == ImageTypeBitmap)
{
- WARN("Failed to save image on stream\n");
- goto out;
- }
+ GpBitmap *bitmap = (GpBitmap*)image;
+ BitmapData lockeddata_src, lockeddata_dst;
+ int i;
+ UINT row_size;
+
+ stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format,
+ &lockeddata_src);
+ if (stat != Ok) return stat;
+
+ stat = GdipCreateBitmapFromScan0(lockeddata_src.Width, lockeddata_src.Height,
+ 0, lockeddata_src.PixelFormat, NULL, (GpBitmap**)cloneImage);
+ if (stat == Ok)
+ {
+ stat = GdipBitmapLockBits((GpBitmap*)*cloneImage, NULL, ImageLockModeWrite,
+ lockeddata_src.PixelFormat, &lockeddata_dst);
+
+ if (stat == Ok)
+ {
+ /* copy the image data */
+ row_size = (lockeddata_src.Width * PIXELFORMATBPP(lockeddata_src.PixelFormat) +7)/8;
+ for (i=0; i<lockeddata_src.Height; i++)
+ memcpy((BYTE*)lockeddata_dst.Scan0+lockeddata_dst.Stride*i,
+ (BYTE*)lockeddata_src.Scan0+lockeddata_src.Stride*i,
+ row_size);
+
+ GdipBitmapUnlockBits((GpBitmap*)*cloneImage, &lockeddata_dst);
+ }
+
+ GdipBitmapUnlockBits(bitmap, &lockeddata_src);
+ }
- hr = OleLoadPicture(stream, size, FALSE, &IID_IPicture,
- (LPVOID*) &(*cloneImage)->picture);
- if (FAILED(hr))
+ if (stat != Ok)
+ {
+ GdipDisposeImage(*cloneImage);
+ *cloneImage = NULL;
+ }
+ else memcpy(&(*cloneImage)->format, &image->format, sizeof(GUID));
+
+ return stat;
+ }
+ else
{
- WARN("Failed to load image from stream\n");
- goto out;
+ ERR("GpImage with no IPicture or bitmap?!\n");
+ return NotImplemented;
}
-
- IStream_Release(stream);
- return Ok;
-out:
- IStream_Release(stream);
- GdipFree(*cloneImage);
- *cloneImage = NULL;
- return GenericError;
}
GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
GpStatus stat;
IStream *stream;
+ TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
+
if(!filename || !bitmap)
return InvalidParameter;
GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
GpBitmap **bitmap)
{
+ TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
+
return GdipCreateBitmapFromFile(filename, bitmap);
}
HBITMAP hbm;
GpStatus stat = InvalidParameter;
+ TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
+
if(!lpBitmapName || !bitmap)
return InvalidParameter;
/* load DIB */
- hbm = (HBITMAP)LoadImageW(hInstance,lpBitmapName,IMAGE_BITMAP,0,0,LR_CREATEDIBSECTION);
+ hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
+ LR_CREATEDIBSECTION);
if(hbm){
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
HBITMAP* hbmReturn, ARGB background)
{
- FIXME("stub\n");
+ GpStatus stat;
+ HBITMAP result, oldbitmap;
+ UINT width, height;
+ HDC hdc;
+ GpGraphics *graphics;
+ BITMAPINFOHEADER bih;
+ void *bits;
+ TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
+
+ if (!bitmap || !hbmReturn) return InvalidParameter;
+
+ GdipGetImageWidth((GpImage*)bitmap, &width);
+ GdipGetImageHeight((GpImage*)bitmap, &height);
+
+ bih.biSize = sizeof(bih);
+ bih.biWidth = width;
+ bih.biHeight = height;
+ bih.biPlanes = 1;
+ bih.biBitCount = 32;
+ bih.biCompression = BI_RGB;
+ bih.biSizeImage = 0;
+ bih.biXPelsPerMeter = 0;
+ bih.biYPelsPerMeter = 0;
+ bih.biClrUsed = 0;
+ bih.biClrImportant = 0;
+
+ hdc = CreateCompatibleDC(NULL);
+ if (!hdc) return GenericError;
+
+ result = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS, &bits,
+ NULL, 0);
+
+ if (result)
+ {
+ oldbitmap = SelectObject(hdc, result);
- hbmReturn = NULL;
+ stat = GdipCreateFromHDC(hdc, &graphics);
+ if (stat == Ok)
+ {
+ stat = GdipGraphicsClear(graphics, background);
- return NotImplemented;
+ if (stat == Ok)
+ stat = GdipDrawImage(graphics, (GpImage*)bitmap, 0, 0);
+
+ GdipDeleteGraphics(graphics);
+ }
+
+ SelectObject(hdc, oldbitmap);
+ }
+ else
+ stat = GenericError;
+
+ DeleteDC(hdc);
+
+ if (stat != Ok && result)
+ {
+ DeleteObject(result);
+ result = NULL;
+ }
+
+ *hbmReturn = result;
+
+ return stat;
}
GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
return ret;
}
-GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
- PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
+GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
{
- BITMAPFILEHEADER *bmfh;
- BITMAPINFOHEADER *bmih;
- BYTE *buff;
- INT datalen, size;
- IStream *stream;
-
- TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
-
- if(!bitmap || width <= 0 || height <= 0 || (scan0 && (stride % 4))){
- *bitmap = NULL;
- return InvalidParameter;
- }
-
- if(scan0 && !stride)
+ GpStatus stat;
+ ICONINFO iinfo;
+ BITMAP bm;
+ int ret;
+ UINT width, height;
+ GpRect rect;
+ BitmapData lockeddata;
+ HDC screendc;
+ BOOL has_alpha;
+ int x, y;
+ BYTE *bits;
+ BITMAPINFOHEADER bih;
+ DWORD *src;
+ BYTE *dst_row;
+ DWORD *dst;
+
+ TRACE("%p, %p\n", hicon, bitmap);
+
+ if(!bitmap || !GetIconInfo(hicon, &iinfo))
return InvalidParameter;
- /* FIXME: windows allows negative stride (reads backwards from scan0) */
- if(stride < 0){
- FIXME("negative stride\n");
- return InvalidParameter;
+ /* get the size of the icon */
+ ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
+ if (ret == 0) {
+ DeleteObject(iinfo.hbmColor);
+ DeleteObject(iinfo.hbmMask);
+ return GenericError;
}
- *bitmap = GdipAlloc(sizeof(GpBitmap));
- if(!*bitmap) return OutOfMemory;
+ width = bm.bmWidth;
- if(stride == 0){
- stride = width * (PIXELFORMATBPP(format) / 8);
- stride = (stride + 3) & ~3;
- }
+ if (iinfo.hbmColor)
+ height = abs(bm.bmHeight);
+ else /* combined bitmap + mask */
+ height = abs(bm.bmHeight) / 2;
- datalen = abs(stride * height);
- size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
- buff = GdipAlloc(size);
- if(!buff){
- GdipFree(*bitmap);
+ bits = HeapAlloc(GetProcessHeap(), 0, 4*width*height);
+ if (!bits) {
+ DeleteObject(iinfo.hbmColor);
+ DeleteObject(iinfo.hbmMask);
return OutOfMemory;
}
- bmfh = (BITMAPFILEHEADER*) buff;
- bmih = (BITMAPINFOHEADER*) (bmfh + 1);
-
- bmfh->bfType = (((WORD)'M') << 8) + (WORD)'B';
- bmfh->bfSize = size;
- bmfh->bfOffBits = size - datalen;
+ stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppARGB, NULL, bitmap);
+ if (stat != Ok) {
+ DeleteObject(iinfo.hbmColor);
+ DeleteObject(iinfo.hbmMask);
+ HeapFree(GetProcessHeap(), 0, bits);
+ return stat;
+ }
- bmih->biSize = sizeof(BITMAPINFOHEADER);
- bmih->biWidth = width;
- bmih->biHeight = -height;
- /* FIXME: use the rest of the data from format */
- bmih->biBitCount = PIXELFORMATBPP(format);
- bmih->biCompression = BI_RGB;
- bmih->biSizeImage = datalen;
+ rect.X = 0;
+ rect.Y = 0;
+ rect.Width = width;
+ rect.Height = height;
+
+ stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
+ if (stat != Ok) {
+ DeleteObject(iinfo.hbmColor);
+ DeleteObject(iinfo.hbmMask);
+ HeapFree(GetProcessHeap(), 0, bits);
+ GdipDisposeImage((GpImage*)*bitmap);
+ return stat;
+ }
- if(scan0)
- memcpy(bmih + 1, scan0, datalen);
+ bih.biSize = sizeof(bih);
+ bih.biWidth = width;
+ bih.biHeight = -height;
+ bih.biPlanes = 1;
+ bih.biBitCount = 32;
+ bih.biCompression = BI_RGB;
+ bih.biSizeImage = 0;
+ bih.biXPelsPerMeter = 0;
+ bih.biYPelsPerMeter = 0;
+ bih.biClrUsed = 0;
+ bih.biClrImportant = 0;
+
+ screendc = GetDC(0);
+ if (iinfo.hbmColor)
+ {
+ GetDIBits(screendc, iinfo.hbmColor, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
+
+ if (bm.bmBitsPixel == 32)
+ {
+ has_alpha = FALSE;
+
+ /* If any pixel has a non-zero alpha, ignore hbmMask */
+ src = (DWORD*)bits;
+ for (x=0; x<width && !has_alpha; x++)
+ for (y=0; y<height && !has_alpha; y++)
+ if ((*src++ & 0xff000000) != 0)
+ has_alpha = TRUE;
+ }
+ else has_alpha = FALSE;
+ }
else
- memset(bmih + 1, 0, datalen);
+ {
+ GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
+ has_alpha = FALSE;
+ }
- if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
- ERR("could not make stream\n");
- GdipFree(*bitmap);
- GdipFree(buff);
- return GenericError;
+ /* copy the image data to the Bitmap */
+ src = (DWORD*)bits;
+ dst_row = lockeddata.Scan0;
+ for (y=0; y<height; y++)
+ {
+ memcpy(dst_row, src, width*4);
+ src += width;
+ dst_row += lockeddata.Stride;
}
- if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
- (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
- TRACE("Could not load picture\n");
- IStream_Release(stream);
- GdipFree(*bitmap);
- GdipFree(buff);
- return GenericError;
+ if (!has_alpha)
+ {
+ if (iinfo.hbmMask)
+ {
+ /* read alpha data from the mask */
+ if (iinfo.hbmColor)
+ GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
+ else
+ GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
+
+ src = (DWORD*)bits;
+ dst_row = lockeddata.Scan0;
+ for (y=0; y<height; y++)
+ {
+ dst = (DWORD*)dst_row;
+ for (x=0; x<height; x++)
+ {
+ DWORD src_value = *src++;
+ if (src_value)
+ *dst++ = 0;
+ else
+ *dst++ |= 0xff000000;
+ }
+ dst_row += lockeddata.Stride;
+ }
+ }
+ else
+ {
+ /* set constant alpha of 255 */
+ dst_row = bits;
+ for (y=0; y<height; y++)
+ {
+ dst = (DWORD*)dst_row;
+ for (x=0; x<height; x++)
+ *dst++ |= 0xff000000;
+ dst_row += lockeddata.Stride;
+ }
+ }
}
- (*bitmap)->image.type = ImageTypeBitmap;
- (*bitmap)->image.flags = ImageFlagsNone;
- (*bitmap)->width = width;
- (*bitmap)->height = height;
- (*bitmap)->format = format;
+ ReleaseDC(0, screendc);
+
+ DeleteObject(iinfo.hbmColor);
+ DeleteObject(iinfo.hbmMask);
+
+ GdipBitmapUnlockBits(*bitmap, &lockeddata);
+
+ HeapFree(GetProcessHeap(), 0, bits);
return Ok;
}
-GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
- GpBitmap **bitmap)
+GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
+ PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
{
- GpStatus stat;
+ BITMAPINFOHEADER bmih;
+ HBITMAP hbitmap;
+ INT row_size, dib_stride;
+ HDC hdc;
+ BYTE *bits;
+ int i;
- stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
+ TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
- if(stat != Ok)
+ if (!bitmap) return InvalidParameter;
+
+ if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
+ *bitmap = NULL;
+ return InvalidParameter;
+ }
+
+ if(scan0 && !stride)
+ return InvalidParameter;
+
+ row_size = (width * PIXELFORMATBPP(format)+7) / 8;
+ dib_stride = (row_size + 3) & ~3;
+
+ if(stride == 0)
+ stride = dib_stride;
+
+ bmih.biSize = sizeof(BITMAPINFOHEADER);
+ bmih.biWidth = width;
+ bmih.biHeight = -height;
+ bmih.biPlanes = 1;
+ /* FIXME: use the rest of the data from format */
+ bmih.biBitCount = PIXELFORMATBPP(format);
+ bmih.biCompression = BI_RGB;
+ bmih.biSizeImage = 0;
+ bmih.biXPelsPerMeter = 0;
+ bmih.biYPelsPerMeter = 0;
+ bmih.biClrUsed = 0;
+ bmih.biClrImportant = 0;
+
+ hdc = CreateCompatibleDC(NULL);
+ if (!hdc) return GenericError;
+
+ hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits,
+ NULL, 0);
+
+ DeleteDC(hdc);
+
+ if (!hbitmap) return GenericError;
+
+ /* copy bits to the dib if necessary */
+ /* FIXME: should reference the bits instead of copying them */
+ if (scan0)
+ for (i=0; i<height; i++)
+ memcpy(bits+i*dib_stride, scan0+i*stride, row_size);
+
+ *bitmap = GdipAlloc(sizeof(GpBitmap));
+ if(!*bitmap)
+ {
+ DeleteObject(hbitmap);
+ return OutOfMemory;
+ }
+
+ (*bitmap)->image.type = ImageTypeBitmap;
+ memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
+ (*bitmap)->image.flags = ImageFlagsNone;
+ (*bitmap)->width = width;
+ (*bitmap)->height = height;
+ (*bitmap)->format = format;
+ (*bitmap)->image.picture = NULL;
+ (*bitmap)->hbitmap = hbitmap;
+ (*bitmap)->hdc = NULL;
+ (*bitmap)->bits = bits;
+ (*bitmap)->stride = dib_stride;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
+ GpBitmap **bitmap)
+{
+ GpStatus stat;
+
+ TRACE("%p %p\n", stream, bitmap);
+
+ stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
+
+ if(stat != Ok)
return stat;
if((*bitmap)->image.type != ImageTypeBitmap){
- IPicture_Release((*bitmap)->image.picture);
- GdipFree(bitmap);
+ GdipDisposeImage(&(*bitmap)->image);
+ *bitmap = NULL;
return GenericError; /* FIXME: what error to return? */
}
GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
GpBitmap **bitmap)
{
+ TRACE("%p %p\n", stream, bitmap);
+
return GdipCreateBitmapFromStream(stream, bitmap);
}
+GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
+ GpCachedBitmap **cachedbmp)
+{
+ GpStatus stat;
+
+ TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
+
+ if(!bitmap || !graphics || !cachedbmp)
+ return InvalidParameter;
+
+ *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
+ if(!*cachedbmp)
+ return OutOfMemory;
+
+ stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
+ if(stat != Ok){
+ GdipFree(*cachedbmp);
+ return stat;
+ }
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
+{
+ FIXME("(%p, %p)\n", bitmap, hicon);
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
+{
+ TRACE("%p\n", cachedbmp);
+
+ if(!cachedbmp)
+ return InvalidParameter;
+
+ GdipDisposeImage(cachedbmp->image);
+ GdipFree(cachedbmp);
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
+ GpCachedBitmap *cachedbmp, INT x, INT y)
+{
+ TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
+
+ if(!graphics || !cachedbmp)
+ return InvalidParameter;
+
+ return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
+}
+
+GpStatus WINGDIPAPI GdipEmfToWmfBits(HENHMETAFILE hemf, UINT cbData16,
+ LPBYTE pData16, INT iMapMode, INT eFlags)
+{
+ FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
+ return NotImplemented;
+}
+
GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
{
- HDC hdc;
+ TRACE("%p\n", image);
if(!image)
return InvalidParameter;
- IPicture_get_CurDC(image->picture, &hdc);
- DeleteDC(hdc);
- IPicture_Release(image->picture);
+ if (image->picture)
+ IPicture_Release(image->picture);
if (image->type == ImageTypeBitmap)
+ {
GdipFree(((GpBitmap*)image)->bitmapbits);
+ DeleteDC(((GpBitmap*)image)->hdc);
+ }
GdipFree(image);
return Ok;
GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
GpUnit *srcUnit)
{
+ TRACE("%p %p %p\n", image, srcRect, srcUnit);
+
if(!image || !srcRect || !srcUnit)
return InvalidParameter;
if(image->type == ImageTypeMetafile){
GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
REAL *height)
{
+ TRACE("%p %p %p\n", image, width, height);
+
if(!image || !height || !width)
return InvalidParameter;
{
HDC hdc;
+ TRACE("%p %p\n", image, graphics);
+
if(!image || !graphics)
return InvalidParameter;
return NotImplemented;
}
- IPicture_get_CurDC(image->picture, &hdc);
+ hdc = ((GpBitmap*)image)->hdc;
if(!hdc){
hdc = CreateCompatibleDC(0);
- IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
+ SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
+ ((GpBitmap*)image)->hdc = hdc;
}
return GdipCreateFromHDC(hdc, graphics);
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
{
+ TRACE("%p %p\n", image, height);
+
if(!image || !height)
return InvalidParameter;
return NotImplemented;
}
+GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
+{
+ FIXME("%p %p\n", image, size);
+
+ if(!image || !size)
+ return InvalidParameter;
+
+ return NotImplemented;
+}
+
/* FIXME: test this function for non-bitmap types */
GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
{
+ TRACE("%p %p\n", image, format);
+
if(!image || !format)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
{
- static int calls;
-
if(!image || !format)
return InvalidParameter;
- if(!(calls++))
- FIXME("not implemented\n");
+ memcpy(format, &image->format, sizeof(GUID));
- return NotImplemented;
+ return Ok;
}
GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
{
+ TRACE("%p %p\n", image, type);
+
if(!image || !type)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
{
+ TRACE("%p %p\n", image, width);
+
if(!image || !width)
return InvalidParameter;
return Ok;
}
+GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
+ UINT num, PropertyItem* items)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return InvalidParameter;
+}
+
+GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return InvalidParameter;
+}
+
+GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return InvalidParameter;
+}
+
+GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
+ PropertyItem* buffer)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return InvalidParameter;
+}
+
GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
UINT* size)
{
return NotImplemented;
}
+GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return InvalidParameter;
+}
+
GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
GDIPCONST GUID* dimensionID, UINT* count)
{
GpStatus stat;
IStream *stream;
+ TRACE("(%s) %p\n", debugstr_w(filename), image);
+
if (!filename || !image)
return InvalidParameter;
/* FIXME: no icm handling */
GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
{
+ TRACE("(%s) %p\n", debugstr_w(filename), image);
+
return GdipLoadImageFromFile(filename, image);
}
-GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
+static const WICPixelFormatGUID *wic_pixel_formats[] = {
+ &GUID_WICPixelFormat16bppBGR555,
+ &GUID_WICPixelFormat24bppBGR,
+ &GUID_WICPixelFormat32bppBGR,
+ &GUID_WICPixelFormat32bppBGRA,
+ &GUID_WICPixelFormat32bppPBGRA,
+ NULL
+};
+
+static const PixelFormat wic_gdip_formats[] = {
+ PixelFormat16bppRGB555,
+ PixelFormat24bppRGB,
+ PixelFormat32bppRGB,
+ PixelFormat32bppARGB,
+ PixelFormat32bppPARGB,
+};
+
+static GpStatus decode_image_wic(IStream* stream, REFCLSID clsid, GpImage **image)
+{
+ GpStatus status=Ok;
+ GpBitmap *bitmap;
+ HRESULT hr;
+ IWICBitmapDecoder *decoder;
+ IWICBitmapFrameDecode *frame;
+ IWICBitmapSource *source=NULL;
+ WICPixelFormatGUID wic_format;
+ PixelFormat gdip_format=0;
+ int i;
+ UINT width, height;
+ BitmapData lockeddata;
+ WICRect wrc;
+ HRESULT initresult;
+
+ initresult = CoInitialize(NULL);
+
+ hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
+ &IID_IWICBitmapDecoder, (void**)&decoder);
+ if (FAILED(hr)) goto end;
+
+ hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)stream, WICDecodeMetadataCacheOnLoad);
+ if (SUCCEEDED(hr))
+ hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
+
+ if (SUCCEEDED(hr)) /* got frame */
+ {
+ hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
+
+ if (SUCCEEDED(hr))
+ {
+ for (i=0; wic_pixel_formats[i]; i++)
+ {
+ if (IsEqualGUID(&wic_format, wic_pixel_formats[i]))
+ {
+ source = (IWICBitmapSource*)frame;
+ IWICBitmapSource_AddRef(source);
+ gdip_format = wic_gdip_formats[i];
+ break;
+ }
+ }
+ if (!source)
+ {
+ /* unknown format; fall back on 32bppARGB */
+ hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
+ gdip_format = PixelFormat32bppARGB;
+ }
+ }
+
+ if (SUCCEEDED(hr)) /* got source */
+ {
+ hr = IWICBitmapSource_GetSize(source, &width, &height);
+
+ if (SUCCEEDED(hr))
+ status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
+ NULL, &bitmap);
+
+ if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
+ {
+ status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
+ gdip_format, &lockeddata);
+ if (status == Ok) /* locked bitmap */
+ {
+ wrc.X = 0;
+ wrc.Width = width;
+ wrc.Height = 1;
+ for (i=0; i<height; i++)
+ {
+ wrc.Y = i;
+ hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
+ abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
+ if (FAILED(hr)) break;
+ }
+
+ GdipBitmapUnlockBits(bitmap, &lockeddata);
+ }
+
+ if (SUCCEEDED(hr) && status == Ok)
+ *image = (GpImage*)bitmap;
+ else
+ {
+ *image = NULL;
+ GdipDisposeImage((GpImage*)bitmap);
+ }
+ }
+
+ IWICBitmapSource_Release(source);
+ }
+
+ IWICBitmapFrameDecode_Release(frame);
+ }
+
+ IWICBitmapDecoder_Release(decoder);
+
+end:
+ if (SUCCEEDED(initresult)) CoUninitialize();
+
+ if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
+
+ return status;
+}
+
+static GpStatus decode_image_icon(IStream* stream, REFCLSID clsid, GpImage **image)
+{
+ return decode_image_wic(stream, &CLSID_WICIcoDecoder, image);
+}
+
+static GpStatus decode_image_bmp(IStream* stream, REFCLSID clsid, GpImage **image)
+{
+ GpStatus status;
+ GpBitmap* bitmap;
+
+ status = decode_image_wic(stream, &CLSID_WICBmpDecoder, image);
+
+ bitmap = (GpBitmap*)*image;
+
+ if (status == Ok && bitmap->format == PixelFormat32bppARGB)
+{
+ /* WIC supports bmp files with alpha, but gdiplus does not */
+ bitmap->format = PixelFormat32bppRGB;
+ }
+
+ return status;
+ }
+
+static GpStatus decode_image_jpeg(IStream* stream, REFCLSID clsid, GpImage **image)
+{
+ return decode_image_wic(stream, &CLSID_WICJpegDecoder, image);
+ }
+
+static GpStatus decode_image_png(IStream* stream, REFCLSID clsid, GpImage **image)
+ {
+ return decode_image_wic(stream, &CLSID_WICPngDecoder, image);
+ }
+
+static GpStatus decode_image_gif(IStream* stream, REFCLSID clsid, GpImage **image)
+{
+ return decode_image_wic(stream, &CLSID_WICGifDecoder, image);
+}
+
+static GpStatus decode_image_olepicture_metafile(IStream* stream, REFCLSID clsid, GpImage **image)
{
IPicture *pic;
- short type;
+
+ TRACE("%p %p\n", stream, image);
if(!stream || !image)
return InvalidParameter;
return GenericError;
}
- IPicture_get_Type(pic, &type);
+ /* FIXME: missing initialization code */
+ *image = GdipAlloc(sizeof(GpMetafile));
+ if(!*image) return OutOfMemory;
+ (*image)->type = ImageTypeMetafile;
+ (*image)->picture = pic;
+ (*image)->flags = ImageFlagsNone;
+
+ return Ok;
+}
- if(type == PICTYPE_BITMAP){
- BITMAPINFO bmi;
- BITMAPCOREHEADER* bmch;
- OLE_HANDLE hbm;
- HDC hdc;
+typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
+ GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params);
- *image = GdipAlloc(sizeof(GpBitmap));
- if(!*image) return OutOfMemory;
- (*image)->type = ImageTypeBitmap;
+typedef GpStatus (*decode_image_func)(IStream *stream, REFCLSID clsid, GpImage** image);
- (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
- (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
+typedef struct image_codec {
+ ImageCodecInfo info;
+ encode_image_func encode_func;
+ decode_image_func decode_func;
+} image_codec;
- /* get the pixel format */
- IPicture_get_Handle(pic, &hbm);
- IPicture_get_CurDC(pic, &hdc);
+typedef enum {
+ BMP,
+ JPEG,
+ GIF,
+ EMF,
+ WMF,
+ PNG,
+ ICO,
+ NUM_CODECS
+} ImageFormat;
- ZeroMemory(&bmi, sizeof(bmi));
- bmch = (BITMAPCOREHEADER*) (&bmi.bmiHeader);
- bmch->bcSize = sizeof(BITMAPCOREHEADER);
+static const struct image_codec codecs[NUM_CODECS];
- if(!hdc){
- HBITMAP old;
- hdc = CreateCompatibleDC(0);
- old = SelectObject(hdc, (HBITMAP)hbm);
- GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
- SelectObject(hdc, old);
- DeleteDC(hdc);
+static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
+{
+ BYTE signature[8];
+ LARGE_INTEGER seek;
+ HRESULT hr;
+ UINT bytesread;
+ int i, j;
+
+ /* seek to the start of the stream */
+ seek.QuadPart = 0;
+ hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
+ if (FAILED(hr)) return hresult_to_status(hr);
+
+ /* read the first 8 bytes */
+ /* FIXME: This assumes all codecs have one signature <= 8 bytes in length */
+ hr = IStream_Read(stream, signature, 8, &bytesread);
+ if (FAILED(hr)) return hresult_to_status(hr);
+ if (hr == S_FALSE || bytesread == 0) return GenericError;
+
+ for (i = 0; i < NUM_CODECS; i++) {
+ if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
+ bytesread >= codecs[i].info.SigSize)
+ {
+ for (j=0; j<codecs[i].info.SigSize; j++)
+ if ((signature[j] & codecs[i].info.SigMask[j]) != codecs[i].info.SigPattern[j])
+ break;
+ if (j == codecs[i].info.SigSize)
+ {
+ *result = &codecs[i];
+ return Ok;
+ }
}
- else
- GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
-
- (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
- }
- else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
- /* FIXME: missing initialization code */
- *image = GdipAlloc(sizeof(GpMetafile));
- if(!*image) return OutOfMemory;
- (*image)->type = ImageTypeMetafile;
- }
- else{
- *image = GdipAlloc(sizeof(GpImage));
- if(!*image) return OutOfMemory;
- (*image)->type = ImageTypeUnknown;
}
- (*image)->picture = pic;
- (*image)->flags = ImageFlagsNone;
+ TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
+ signature[0],signature[1],signature[2],signature[3],
+ signature[4],signature[5],signature[6],signature[7]);
- return Ok;
+ return GenericError;
+}
+
+GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
+{
+ GpStatus stat;
+ LARGE_INTEGER seek;
+ HRESULT hr;
+ const struct image_codec *codec=NULL;
+
+ /* choose an appropriate image decoder */
+ stat = get_decoder_info(stream, &codec);
+ if (stat != Ok) return stat;
+
+ /* seek to the start of the stream */
+ seek.QuadPart = 0;
+ hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
+ if (FAILED(hr)) return hresult_to_status(hr);
+
+ /* call on the image decoder to do the real work */
+ stat = codec->decode_func(stream, &codec->info.Clsid, image);
+
+ /* take note of the original data format */
+ if (stat == Ok)
+ {
+ memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
+}
+
+ return stat;
}
/* FIXME: no ICM */
GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
{
+ TRACE("%p %p\n", stream, image);
+
return GdipLoadImageFromStream(stream, image);
}
return NotImplemented;
}
+GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return NotImplemented;
+}
+
GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
GDIPCONST CLSID *clsidEncoder,
GDIPCONST EncoderParameters *encoderParams)
GpStatus stat;
IStream *stream;
- if (!image || !filename|| !clsidEncoder)
- return InvalidParameter;
+ TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
- if (!(image->picture))
+ if (!image || !filename|| !clsidEncoder)
return InvalidParameter;
stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
#define BITMAP_FORMAT_PNG 0x5089
#define BITMAP_FORMAT_APM 0xcdd7
-static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
- void **output, unsigned int *output_size)
+static GpStatus encode_image_WIC(GpImage *image, IStream* stream,
+ GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
{
- int num_palette_entries;
- BITMAPFILEHEADER *bmp_file_hdr;
- BITMAPINFO *bmp_info_hdr;
+ GpStatus stat;
+ GpBitmap *bitmap;
+ IWICBitmapEncoder *encoder;
+ IWICBitmapFrameEncode *frameencode;
+ IPropertyBag2 *encoderoptions;
+ HRESULT hr;
+ UINT width, height;
+ PixelFormat gdipformat=0;
+ WICPixelFormatGUID wicformat;
+ GpRect rc;
+ BitmapData lockeddata;
+ HRESULT initresult;
+ UINT i;
+
+ if (image->type != ImageTypeBitmap)
+ return GenericError;
- if (bitmap_info->bmiHeader.biClrUsed) {
- num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
- if (num_palette_entries > 256) num_palette_entries = 256;
- } else {
- if (bitmap_info->bmiHeader.biBitCount <= 8)
- num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
- else
- num_palette_entries = 0;
+ bitmap = (GpBitmap*)image;
+
+ GdipGetImageWidth(image, &width);
+ GdipGetImageHeight(image, &height);
+
+ rc.X = 0;
+ rc.Y = 0;
+ rc.Width = width;
+ rc.Height = height;
+
+ initresult = CoInitialize(NULL);
+
+ hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER,
+ &IID_IWICBitmapEncoder, (void**)&encoder);
+ if (FAILED(hr))
+ {
+ if (SUCCEEDED(initresult)) CoUninitialize();
+ return hresult_to_status(hr);
+ }
+
+ hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
+
+ if (SUCCEEDED(hr))
+ {
+ hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
}
- *output_size =
- sizeof(BITMAPFILEHEADER) +
- sizeof(BITMAPINFOHEADER) +
- num_palette_entries * sizeof(RGBQUAD) +
- bitmap_info->bmiHeader.biSizeImage;
+ if (SUCCEEDED(hr)) /* created frame */
+ {
+ hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
+
+ if (SUCCEEDED(hr))
+ hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
+
+ if (SUCCEEDED(hr))
+ /* FIXME: use the resolution from the image */
+ hr = IWICBitmapFrameEncode_SetResolution(frameencode, 96.0, 96.0);
+
+ if (SUCCEEDED(hr))
+ {
+ for (i=0; wic_pixel_formats[i]; i++)
+ {
+ if (wic_gdip_formats[i] == bitmap->format)
+ break;
+ }
+ if (wic_pixel_formats[i])
+ memcpy(&wicformat, wic_pixel_formats[i], sizeof(GUID));
+ else
+ memcpy(&wicformat, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
+
+ hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
+
+ for (i=0; wic_pixel_formats[i]; i++)
+ {
+ if (IsEqualGUID(&wicformat, wic_pixel_formats[i]))
+ break;
+ }
+ if (wic_pixel_formats[i])
+ gdipformat = wic_gdip_formats[i];
+ else
+ {
+ ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat));
+ hr = E_FAIL;
+ }
+ }
- *output = GdipAlloc(*output_size);
+ if (SUCCEEDED(hr))
+ {
+ stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
+ &lockeddata);
+
+ if (stat == Ok)
+ {
+ UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
+ BYTE *row;
+
+ /* write one row at a time in case stride is negative */
+ row = lockeddata.Scan0;
+ for (i=0; i<lockeddata.Height; i++)
+ {
+ hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
+ if (FAILED(hr)) break;
+ row += lockeddata.Stride;
+ }
+
+ GdipBitmapUnlockBits(bitmap, &lockeddata);
+ }
+ else
+ hr = E_FAIL;
+ }
- bmp_file_hdr = (BITMAPFILEHEADER*) *output;
- bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
- bmp_file_hdr->bfSize = *output_size;
- bmp_file_hdr->bfOffBits =
- sizeof(BITMAPFILEHEADER) +
- sizeof(BITMAPINFOHEADER) +
- num_palette_entries * sizeof (RGBQUAD);
+ if (SUCCEEDED(hr))
+ hr = IWICBitmapFrameEncode_Commit(frameencode);
- bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
- memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
- memcpy((unsigned char *)(*output) +
- sizeof(BITMAPFILEHEADER) +
- sizeof(BITMAPINFOHEADER) +
- num_palette_entries * sizeof(RGBQUAD),
- bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
+ IWICBitmapFrameEncode_Release(frameencode);
+ IPropertyBag2_Release(encoderoptions);
+ }
- return Ok;
-}
+ if (SUCCEEDED(hr))
+ hr = IWICBitmapEncoder_Commit(encoder);
-typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
- void **output, unsigned int *output_size);
+ IWICBitmapEncoder_Release(encoder);
-typedef enum {
- BMP,
- NUM_ENCODERS_SUPPORTED
-} ImageFormat;
+ if (SUCCEEDED(initresult)) CoUninitialize();
-static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
-static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
- encode_image_BMP,
-};
+ return hresult_to_status(hr);
+}
+
+static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
+ GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
+{
+ return encode_image_WIC(image, stream, &CLSID_WICBmpEncoder, params);
+}
+
+static GpStatus encode_image_png(GpImage *image, IStream* stream,
+ GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
+{
+ return encode_image_WIC(image, stream, &CLSID_WICPngEncoder, params);
+}
/*****************************************************************************
* GdipSaveImageToStream [GDIPLUS.@]
GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
{
GpStatus stat;
- HRESULT hr;
- short type;
- HBITMAP hbmp;
- HBITMAP old_hbmp;
- HDC hdc;
- int bm_is_selected;
- BITMAPINFO bmp_info;
- LPVOID bmp_bits;
- encode_image_func* encode_image;
- LPVOID output;
- unsigned int output_size;
- unsigned int dummy;
+ encode_image_func encode_image;
int i;
- old_hbmp = 0;
- output = NULL;
- output_size = 0;
+ TRACE("%p %p %p %p\n", image, stream, clsid, params);
if(!image || !stream)
return InvalidParameter;
- if (!image->picture)
- return GenericError;
-
- hr = IPicture_get_Type(image->picture, &type);
- if (FAILED(hr) || type != PICTYPE_BITMAP)
- return GenericError;
-
/* select correct encoder */
encode_image = NULL;
- for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
- if (IsEqualCLSID(clsid, &codecs[i].Clsid))
- encode_image = encode_image_funcs[i];
+ for (i = 0; i < NUM_CODECS; i++) {
+ if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
+ IsEqualCLSID(clsid, &codecs[i].info.Clsid))
+ encode_image = codecs[i].encode_func;
}
if (encode_image == NULL)
return UnknownImageFormat;
- /* extract underlying hbitmap representation from the IPicture */
- hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
- if (FAILED(hr) || !hbmp)
- return GenericError;
- hr = IPicture_get_CurDC(image->picture, &hdc);
- if (FAILED(hr))
- return GenericError;
- bm_is_selected = (hdc != 0);
- if (!bm_is_selected) {
- hdc = CreateCompatibleDC(0);
- old_hbmp = SelectObject(hdc, hbmp);
- }
-
- /* get bits from HBITMAP */
- bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
- bmp_info.bmiHeader.biBitCount = 0;
- GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
+ stat = encode_image(image, stream, clsid, params);
- bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
-
- if (bmp_bits)
- GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
-
- if (!bm_is_selected) {
- SelectObject(hdc, old_hbmp);
- DeleteDC(hdc);
- }
+ return stat;
+}
- if (!bmp_bits)
- return OutOfMemory;
+/*****************************************************************************
+ * GdipGetImagePalette [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
+{
+ static int calls = 0;
- stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
- if (stat == Ok)
- IStream_Write(stream, output, output_size, &dummy);
+ if(!image)
+ return InvalidParameter;
- GdipFree(output);
- GdipFree(bmp_bits);
+ if(!(calls++))
+ FIXME("not implemented\n");
- return stat;
+ return NotImplemented;
}
/*****************************************************************************
static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
-static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
+static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
+static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
+static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
+static const WCHAR jpeg_format[] = {'J','P','E','G',0};
+static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
+static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
+
+static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
+static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
+static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
+static const WCHAR gif_format[] = {'G','I','F',0};
+static const BYTE gif_sig_pattern[4] = "GIF8";
+static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+
+static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
+static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
+static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
+static const WCHAR emf_format[] = {'E','M','F',0};
+static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
+static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+
+static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
+static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
+static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
+static const WCHAR wmf_format[] = {'W','M','F',0};
+static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
+static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
+
+static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
+static const WCHAR png_extension[] = {'*','.','P','N','G',0};
+static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
+static const WCHAR png_format[] = {'P','N','G',0};
+static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
+static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
+static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
+static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
+static const WCHAR ico_format[] = {'I','C','O',0};
+static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
+static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
+
+static const struct image_codec codecs[NUM_CODECS] = {
{
{ /* BMP */
/* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
/* SigPattern */ bmp_sig_pattern,
/* SigMask */ bmp_sig_mask,
},
- };
+ encode_image_BMP,
+ decode_image_bmp
+ },
+ {
+ { /* JPEG */
+ /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ jpeg_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ jpeg_format,
+ /* FilenameExtension */ jpeg_extension,
+ /* MimeType */ jpeg_mimetype,
+ /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 2,
+ /* SigPattern */ jpeg_sig_pattern,
+ /* SigMask */ jpeg_sig_mask,
+ },
+ NULL,
+ decode_image_jpeg
+ },
+ {
+ { /* GIF */
+ /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ gif_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ gif_format,
+ /* FilenameExtension */ gif_extension,
+ /* MimeType */ gif_mimetype,
+ /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 4,
+ /* SigPattern */ gif_sig_pattern,
+ /* SigMask */ gif_sig_mask,
+ },
+ NULL,
+ decode_image_gif
+ },
+ {
+ { /* EMF */
+ /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ emf_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ emf_format,
+ /* FilenameExtension */ emf_extension,
+ /* MimeType */ emf_mimetype,
+ /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 4,
+ /* SigPattern */ emf_sig_pattern,
+ /* SigMask */ emf_sig_mask,
+ },
+ NULL,
+ decode_image_olepicture_metafile
+ },
+ {
+ { /* WMF */
+ /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ wmf_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ wmf_format,
+ /* FilenameExtension */ wmf_extension,
+ /* MimeType */ wmf_mimetype,
+ /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 2,
+ /* SigPattern */ wmf_sig_pattern,
+ /* SigMask */ wmf_sig_mask,
+ },
+ NULL,
+ decode_image_olepicture_metafile
+ },
+ {
+ { /* PNG */
+ /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ png_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ png_format,
+ /* FilenameExtension */ png_extension,
+ /* MimeType */ png_mimetype,
+ /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 8,
+ /* SigPattern */ png_sig_pattern,
+ /* SigMask */ png_sig_mask,
+ },
+ encode_image_png,
+ decode_image_png
+ },
+ {
+ { /* ICO */
+ /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
+ /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
+ /* CodecName */ ico_codecname,
+ /* DllName */ NULL,
+ /* FormatDescription */ ico_format,
+ /* FilenameExtension */ ico_extension,
+ /* MimeType */ ico_mimetype,
+ /* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
+ /* Version */ 1,
+ /* SigCount */ 1,
+ /* SigSize */ 4,
+ /* SigPattern */ ico_sig_pattern,
+ /* SigMask */ ico_sig_mask,
+ },
+ NULL,
+ decode_image_icon
+ },
+};
+
+/*****************************************************************************
+ * GdipGetImageDecodersSize [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
+{
+ int decoder_count=0;
+ int i;
+ TRACE("%p %p\n", numDecoders, size);
+
+ if (!numDecoders || !size)
+ return InvalidParameter;
+
+ for (i=0; i<NUM_CODECS; i++)
+ {
+ if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
+ decoder_count++;
+ }
+
+ *numDecoders = decoder_count;
+ *size = decoder_count * sizeof(ImageCodecInfo);
+
+ return Ok;
+}
+
+/*****************************************************************************
+ * GdipGetImageDecoders [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
+{
+ int i, decoder_count=0;
+ TRACE("%u %u %p\n", numDecoders, size, decoders);
+
+ if (!decoders ||
+ size != numDecoders * sizeof(ImageCodecInfo))
+ return GenericError;
+
+ for (i=0; i<NUM_CODECS; i++)
+ {
+ if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
+ {
+ if (decoder_count == numDecoders) return GenericError;
+ memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
+ decoder_count++;
+ }
+ }
+
+ if (decoder_count < numDecoders) return GenericError;
+
+ return Ok;
+}
/*****************************************************************************
* GdipGetImageEncodersSize [GDIPLUS.@]
*/
GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
{
+ int encoder_count=0;
+ int i;
+ TRACE("%p %p\n", numEncoders, size);
+
if (!numEncoders || !size)
return InvalidParameter;
- *numEncoders = NUM_ENCODERS_SUPPORTED;
- *size = sizeof (codecs);
+ for (i=0; i<NUM_CODECS; i++)
+ {
+ if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
+ encoder_count++;
+ }
+
+ *numEncoders = encoder_count;
+ *size = encoder_count * sizeof(ImageCodecInfo);
return Ok;
}
*/
GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
{
+ int i, encoder_count=0;
+ TRACE("%u %u %p\n", numEncoders, size, encoders);
+
if (!encoders ||
- (numEncoders != NUM_ENCODERS_SUPPORTED) ||
- (size != sizeof (codecs)))
+ size != numEncoders * sizeof(ImageCodecInfo))
return GenericError;
- memcpy(encoders, codecs, sizeof (codecs));
+ for (i=0; i<NUM_CODECS; i++)
+ {
+ if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
+ {
+ if (encoder_count == numEncoders) return GenericError;
+ memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
+ encoder_count++;
+ }
+ }
+
+ if (encoder_count < numEncoders) return GenericError;
return Ok;
}
BITMAP bm;
GpStatus retval;
PixelFormat format;
+ BYTE* bits;
+
+ TRACE("%p %p %p\n", hbm, hpal, bitmap);
if(!hbm || !bitmap)
return InvalidParameter;
case 24:
format = PixelFormat24bppRGB;
break;
+ case 32:
+ format = PixelFormat32bppRGB;
+ break;
case 48:
format = PixelFormat48bppRGB;
break;
return InvalidParameter;
}
- retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
- format, bm.bmBits, bitmap);
+ if (bm.bmBits)
+ bits = (BYTE*)bm.bmBits + (bm.bmHeight - 1) * bm.bmWidthBytes;
+ else
+ {
+ FIXME("can only get image data from DIB sections\n");
+ bits = NULL;
+ }
+
+ retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, -bm.bmWidthBytes,
+ format, bits, bitmap);
return retval;
}
+GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
+{
+ FIXME("(%p): stub\n", effect);
+ /* note: According to Jose Roca's GDI+ Docs, this is not implemented
+ * in Windows's gdiplus */
+ return NotImplemented;
+}
+
/*****************************************************************************
* GdipSetEffectParameters [GDIPLUS.@]
*/
*/
GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
{
+ TRACE("%p %p\n", image, flags);
+
if(!image || !flags)
return InvalidParameter;
return Ok;
}
+
+GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
+{
+ TRACE("(%d, %p)\n", control, param);
+
+ switch(control){
+ case TestControlForceBilinear:
+ if(param)
+ FIXME("TestControlForceBilinear not handled\n");
+ break;
+ case TestControlNoICM:
+ if(param)
+ FIXME("TestControlNoICM not handled\n");
+ break;
+ case TestControlGetBuildNumber:
+ *((DWORD*)param) = 3102;
+ break;
+ }
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
+ HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
+ MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
+ GpMetafile **metafile)
+{
+ FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
+ frameUnit, debugstr_w(desc), metafile);
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
+ GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
+ GDIPCONST WCHAR *desc, GpMetafile **metafile)
+{
+ FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
+ frameUnit, debugstr_w(desc), metafile);
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
+{
+ FIXME("%p\n", image);
+
+ return Ok;
+}
+
+/*****************************************************************************
+ * GdipGetImageThumbnail [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
+ GpImage **ret_image, GetThumbnailImageAbort cb,
+ VOID * cb_data)
+{
+ FIXME("(%p %u %u %p %p %p) stub\n",
+ image, width, height, ret_image, cb, cb_data);
+ return NotImplemented;
+}
+
+/*****************************************************************************
+ * GdipImageRotateFlip [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
+{
+ FIXME("(%p %u) stub\n", image, type);
+ return NotImplemented;
+}
projects / reactos.git / blobdiff