mirror of
git://source.winehq.org/git/wine.git
synced 2024-11-01 09:50:52 +00:00
af403bd34f
Signed-off-by: Eric Pouech <eric.pouech@gmail.com> Signed-off-by: Esme Povirk <esme@codeweavers.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
5917 lines
181 KiB
C
5917 lines
181 KiB
C
/*
|
|
* Copyright (C) 2007 Google (Evan Stade)
|
|
* Copyright (C) 2012,2016 Dmitry Timoshkov
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <assert.h>
|
|
|
|
#define NONAMELESSUNION
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winuser.h"
|
|
#include "wingdi.h"
|
|
|
|
#define COBJMACROS
|
|
#include "objbase.h"
|
|
#include "olectl.h"
|
|
#include "ole2.h"
|
|
|
|
#include "initguid.h"
|
|
#include "wincodec.h"
|
|
#include "gdiplus.h"
|
|
#include "gdiplus_private.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
|
|
|
|
HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
|
|
|
|
#define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
|
|
#define WMF_PLACEABLE_KEY 0x9ac6cdd7
|
|
|
|
static const struct
|
|
{
|
|
const WICPixelFormatGUID *wic_format;
|
|
PixelFormat gdip_format;
|
|
/* predefined palette type to use for pixel format conversions */
|
|
WICBitmapPaletteType palette_type;
|
|
} pixel_formats[] =
|
|
{
|
|
{ &GUID_WICPixelFormat1bppIndexed, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
|
|
{ &GUID_WICPixelFormatBlackWhite, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
|
|
{ &GUID_WICPixelFormat4bppIndexed, PixelFormat4bppIndexed, WICBitmapPaletteTypeFixedHalftone8 },
|
|
{ &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
|
|
{ &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
|
|
{ &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, 0 },
|
|
{ &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, 0 },
|
|
{ &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, 0 },
|
|
{ &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, 0 },
|
|
{ &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, 0 },
|
|
{ NULL }
|
|
};
|
|
|
|
static ColorPalette *get_palette(IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)
|
|
{
|
|
HRESULT hr;
|
|
IWICImagingFactory *factory;
|
|
IWICPalette *wic_palette;
|
|
ColorPalette *palette = NULL;
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (hr != S_OK) return NULL;
|
|
|
|
hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
|
|
if (frame)
|
|
hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
|
|
if (hr != S_OK && palette_type != 0)
|
|
{
|
|
TRACE("using predefined palette %#x\n", palette_type);
|
|
hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
|
|
}
|
|
if (hr == S_OK)
|
|
{
|
|
WICBitmapPaletteType type;
|
|
BOOL alpha;
|
|
UINT count;
|
|
|
|
IWICPalette_GetColorCount(wic_palette, &count);
|
|
palette = heap_alloc(2 * sizeof(UINT) + count * sizeof(ARGB));
|
|
IWICPalette_GetColors(wic_palette, count, (UINT *)palette->Entries, &palette->Count);
|
|
|
|
IWICPalette_GetType(wic_palette, &type);
|
|
switch(type) {
|
|
case WICBitmapPaletteTypeFixedGray4:
|
|
case WICBitmapPaletteTypeFixedGray16:
|
|
case WICBitmapPaletteTypeFixedGray256:
|
|
palette->Flags = PaletteFlagsGrayScale;
|
|
break;
|
|
case WICBitmapPaletteTypeFixedHalftone8:
|
|
case WICBitmapPaletteTypeFixedHalftone27:
|
|
case WICBitmapPaletteTypeFixedHalftone64:
|
|
case WICBitmapPaletteTypeFixedHalftone125:
|
|
case WICBitmapPaletteTypeFixedHalftone216:
|
|
case WICBitmapPaletteTypeFixedHalftone252:
|
|
case WICBitmapPaletteTypeFixedHalftone256:
|
|
palette->Flags = PaletteFlagsHalftone;
|
|
break;
|
|
default:
|
|
palette->Flags = 0;
|
|
}
|
|
IWICPalette_HasAlpha(wic_palette, &alpha);
|
|
if(alpha)
|
|
palette->Flags |= PaletteFlagsHasAlpha;
|
|
}
|
|
IWICPalette_Release(wic_palette);
|
|
}
|
|
IWICImagingFactory_Release(factory);
|
|
return palette;
|
|
}
|
|
|
|
static HRESULT set_palette(IWICBitmapFrameEncode *frame, ColorPalette *palette)
|
|
{
|
|
HRESULT hr;
|
|
IWICImagingFactory *factory;
|
|
IWICPalette *wic_palette;
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
|
|
IWICImagingFactory_Release(factory);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IWICPalette_InitializeCustom(wic_palette, (UINT *)palette->Entries, palette->Count);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = IWICBitmapFrameEncode_SetPalette(frame, wic_palette);
|
|
|
|
IWICPalette_Release(wic_palette);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
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_1bppIndexed(BYTE *index, const BYTE *row, UINT x)
|
|
{
|
|
*index = (row[x/8]>>(7-x%8)) & 1;
|
|
}
|
|
|
|
static inline void getpixel_4bppIndexed(BYTE *index, const BYTE *row, UINT x)
|
|
{
|
|
if (x & 1)
|
|
*index = row[x/2]&0xf;
|
|
else
|
|
*index = row[x/2]>>4;
|
|
}
|
|
|
|
static inline void getpixel_8bppIndexed(BYTE *index, const BYTE *row, UINT x)
|
|
{
|
|
*index = row[x];
|
|
}
|
|
|
|
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 = *((const 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 = *((const 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 = *((const 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 = row[x*4+2];
|
|
*g = row[x*4+1];
|
|
*b = row[x*4];
|
|
}
|
|
else
|
|
{
|
|
DWORD scaled_q = (255 << 15) / *a;
|
|
*r = (row[x*4+2] > *a) ? 0xff : (row[x*4+2] * scaled_q) >> 15;
|
|
*g = (row[x*4+1] > *a) ? 0xff : (row[x*4+1] * scaled_q) >> 15;
|
|
*b = (row[x*4] > *a) ? 0xff : (row[x*4] * scaled_q) >> 15;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
BYTE r, g, b, a;
|
|
BYTE index;
|
|
BYTE *row;
|
|
|
|
if(!bitmap || !color ||
|
|
x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
|
|
return InvalidParameter;
|
|
|
|
row = bitmap->bits+bitmap->stride*y;
|
|
|
|
switch (bitmap->format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
getpixel_1bppIndexed(&index,row,x);
|
|
break;
|
|
case PixelFormat4bppIndexed:
|
|
getpixel_4bppIndexed(&index,row,x);
|
|
break;
|
|
case PixelFormat8bppIndexed:
|
|
getpixel_8bppIndexed(&index,row,x);
|
|
break;
|
|
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;
|
|
}
|
|
|
|
if (bitmap->format & PixelFormatIndexed)
|
|
*color = bitmap->image.palette->Entries[index];
|
|
else
|
|
*color = a<<24|r<<16|g<<8|b;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
static unsigned int absdiff(unsigned int x, unsigned int y)
|
|
{
|
|
return x > y ? x - y : y - x;
|
|
}
|
|
|
|
static inline UINT get_palette_index(BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)
|
|
{
|
|
BYTE index = 0;
|
|
int best_distance = 0x7fff;
|
|
int distance;
|
|
UINT i;
|
|
|
|
if (!palette) return 0;
|
|
/* This algorithm scans entire palette,
|
|
computes difference from desired color (all color components have equal weight)
|
|
and returns the index of color with least difference.
|
|
|
|
Note: Maybe it could be replaced with a better algorithm for better image quality
|
|
and performance, though better algorithm would probably need some pre-built lookup
|
|
tables and thus may actually be slower if this method is called only few times per
|
|
every image.
|
|
*/
|
|
for(i=0;i<palette->Count;i++) {
|
|
ARGB color=palette->Entries[i];
|
|
distance=absdiff(b, color & 0xff) + absdiff(g, color>>8 & 0xff) + absdiff(r, color>>16 & 0xff) + absdiff(a, color>>24 & 0xff);
|
|
if (distance<best_distance) {
|
|
best_distance=distance;
|
|
index=i;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
static inline void setpixel_8bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
|
|
BYTE *row, UINT x, ColorPalette *palette)
|
|
{
|
|
BYTE index = get_palette_index(r,g,b,a,palette);
|
|
row[x]=index;
|
|
}
|
|
|
|
static inline void setpixel_1bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
|
|
BYTE *row, UINT x, ColorPalette *palette)
|
|
{
|
|
row[x/8] = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
|
|
}
|
|
|
|
static inline void setpixel_4bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
|
|
BYTE *row, UINT x, ColorPalette *palette)
|
|
{
|
|
if (x & 1)
|
|
row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
|
|
else
|
|
row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
|
|
}
|
|
|
|
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 + 127) / 255;
|
|
g = (g * a + 127) / 255;
|
|
b = (b * a + 127) / 255;
|
|
*((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
case PixelFormat8bppIndexed:
|
|
setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
|
|
break;
|
|
case PixelFormat4bppIndexed:
|
|
setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
|
|
break;
|
|
case PixelFormat1bppIndexed:
|
|
setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
|
|
break;
|
|
default:
|
|
FIXME("not implemented for format 0x%x\n", bitmap->format);
|
|
return NotImplemented;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus convert_pixels(INT width, INT height,
|
|
INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
|
|
ColorPalette *dst_palette,
|
|
INT src_stride, const BYTE *src_bits, PixelFormat src_format,
|
|
ColorPalette *src_palette)
|
|
{
|
|
INT x, y;
|
|
|
|
if (src_format == dst_format ||
|
|
(dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
|
|
{
|
|
UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
|
|
for (y=0; y<height; y++)
|
|
memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
|
|
return Ok;
|
|
}
|
|
|
|
#define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
|
|
for (y=0; y<height; y++) \
|
|
for (x=0; x<width; x++) { \
|
|
BYTE index; \
|
|
ARGB argb; \
|
|
BYTE *color = (BYTE *)&argb; \
|
|
getpixel_function(&index, src_bits+src_stride*y, x); \
|
|
argb = (src_palette && index < src_palette->Count) ? src_palette->Entries[index] : 0; \
|
|
setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
|
|
} \
|
|
return Ok; \
|
|
} while (0);
|
|
|
|
#define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
|
|
for (y=0; y<height; y++) \
|
|
for (x=0; x<width; x++) { \
|
|
BYTE r, g, b, a; \
|
|
getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
|
|
setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
|
|
} \
|
|
return Ok; \
|
|
} while (0);
|
|
|
|
#define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
|
|
for (y=0; y<height; y++) \
|
|
for (x=0; x<width; x++) { \
|
|
BYTE r, g, b, a; \
|
|
getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
|
|
setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, dst_palette); \
|
|
} \
|
|
return Ok; \
|
|
} while (0);
|
|
|
|
switch (src_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat16bppGrayScale:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat4bppIndexed:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat16bppGrayScale:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat8bppIndexed:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat16bppGrayScale:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat16bppGrayScale:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat16bppRGB555:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat16bppRGB565:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat16bppARGB1555:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat24bppRGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat32bppRGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat32bppARGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
|
|
return Ok;
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat32bppPARGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat48bppRGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat64bppARGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case PixelFormat64bppPARGB:
|
|
switch (dst_format)
|
|
{
|
|
case PixelFormat1bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
|
|
case PixelFormat4bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_4bppIndexed);
|
|
case PixelFormat8bppIndexed:
|
|
convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
|
|
case PixelFormat16bppGrayScale:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
|
|
case PixelFormat16bppRGB555:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
|
|
case PixelFormat16bppRGB565:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
|
|
case PixelFormat16bppARGB1555:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
|
|
case PixelFormat24bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
|
|
case PixelFormat32bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
|
|
case PixelFormat32bppARGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
|
|
case PixelFormat32bppPARGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
|
|
case PixelFormat48bppRGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
|
|
case PixelFormat64bppARGB:
|
|
convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
#undef convert_indexed_to_rgb
|
|
#undef convert_rgb_to_rgb
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
/* 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
|
|
* privileges can write to the whole bitmap (not just the area in rect).
|
|
*
|
|
* FIXME: only used portion of format is bits per pixel. */
|
|
GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
|
|
UINT flags, PixelFormat format, BitmapData* lockeddata)
|
|
{
|
|
INT bitspp = PIXELFORMATBPP(format);
|
|
GpRect act_rect; /* actual rect to be used */
|
|
GpStatus stat;
|
|
BOOL unlock;
|
|
|
|
TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
|
|
|
|
if(!lockeddata || !bitmap)
|
|
return InvalidParameter;
|
|
if(!image_lock(&bitmap->image, &unlock))
|
|
return ObjectBusy;
|
|
|
|
if(rect){
|
|
if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
|
|
(rect->Y + rect->Height > bitmap->height) || !flags)
|
|
{
|
|
image_unlock(&bitmap->image, unlock);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
act_rect = *rect;
|
|
}
|
|
else{
|
|
act_rect.X = act_rect.Y = 0;
|
|
act_rect.Width = bitmap->width;
|
|
act_rect.Height = bitmap->height;
|
|
}
|
|
|
|
if(bitmap->lockmode)
|
|
{
|
|
WARN("bitmap is already locked and cannot be locked again\n");
|
|
image_unlock(&bitmap->image, unlock);
|
|
return WrongState;
|
|
}
|
|
|
|
if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
|
|
{
|
|
/* 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 | ImageLockModeRead;
|
|
|
|
image_unlock(&bitmap->image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
/* Make sure we can convert to the requested format. */
|
|
if (flags & ImageLockModeRead)
|
|
{
|
|
stat = convert_pixels(0, 0, 0, NULL, format, NULL, 0, NULL, bitmap->format, NULL);
|
|
if (stat == NotImplemented)
|
|
{
|
|
FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
|
|
image_unlock(&bitmap->image, unlock);
|
|
return NotImplemented;
|
|
}
|
|
}
|
|
|
|
/* If we're opening for writing, make sure we'll be able to write back in
|
|
* the original format. */
|
|
if (flags & ImageLockModeWrite)
|
|
{
|
|
stat = convert_pixels(0, 0, 0, NULL, bitmap->format, NULL, 0, NULL, format, NULL);
|
|
if (stat == NotImplemented)
|
|
{
|
|
FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
|
|
image_unlock(&bitmap->image, unlock);
|
|
return NotImplemented;
|
|
}
|
|
}
|
|
|
|
lockeddata->Width = act_rect.Width;
|
|
lockeddata->Height = act_rect.Height;
|
|
lockeddata->PixelFormat = format;
|
|
lockeddata->Reserved = flags;
|
|
|
|
if(!(flags & ImageLockModeUserInputBuf))
|
|
{
|
|
lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
|
|
|
|
bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
|
|
|
|
if (!bitmap->bitmapbits)
|
|
{
|
|
image_unlock(&bitmap->image, unlock);
|
|
return OutOfMemory;
|
|
}
|
|
|
|
lockeddata->Scan0 = bitmap->bitmapbits;
|
|
}
|
|
|
|
if (flags & ImageLockModeRead)
|
|
{
|
|
static BOOL fixme = FALSE;
|
|
|
|
if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
|
|
{
|
|
FIXME("Cannot copy rows that don't start at a whole byte.\n");
|
|
fixme = TRUE;
|
|
}
|
|
|
|
stat = convert_pixels(act_rect.Width, act_rect.Height,
|
|
lockeddata->Stride, lockeddata->Scan0, format, bitmap->image.palette,
|
|
bitmap->stride,
|
|
bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
|
|
bitmap->format, bitmap->image.palette);
|
|
|
|
if (stat != Ok)
|
|
{
|
|
heap_free(bitmap->bitmapbits);
|
|
bitmap->bitmapbits = NULL;
|
|
image_unlock(&bitmap->image, unlock);
|
|
return stat;
|
|
}
|
|
}
|
|
|
|
bitmap->lockmode = flags | ImageLockModeRead;
|
|
bitmap->lockx = act_rect.X;
|
|
bitmap->locky = act_rect.Y;
|
|
|
|
image_unlock(&bitmap->image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
|
|
{
|
|
TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
|
|
|
|
if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
|
|
return InvalidParameter;
|
|
|
|
bitmap->image.xres = xdpi;
|
|
bitmap->image.yres = ydpi;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
|
|
BitmapData* lockeddata)
|
|
{
|
|
GpStatus stat;
|
|
static BOOL fixme = FALSE;
|
|
BOOL unlock;
|
|
|
|
TRACE("(%p,%p)\n", bitmap, lockeddata);
|
|
|
|
if(!bitmap || !lockeddata)
|
|
return InvalidParameter;
|
|
if(!image_lock(&bitmap->image, &unlock))
|
|
return ObjectBusy;
|
|
|
|
if(!bitmap->lockmode)
|
|
{
|
|
image_unlock(&bitmap->image, unlock);
|
|
return WrongState;
|
|
}
|
|
|
|
if(!(lockeddata->Reserved & ImageLockModeWrite)){
|
|
bitmap->lockmode = 0;
|
|
heap_free(bitmap->bitmapbits);
|
|
bitmap->bitmapbits = NULL;
|
|
image_unlock(&bitmap->image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
|
|
{
|
|
/* we passed a direct reference; no need to do anything */
|
|
bitmap->lockmode = 0;
|
|
image_unlock(&bitmap->image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
|
|
{
|
|
FIXME("Cannot copy rows that don't start at a whole byte.\n");
|
|
fixme = TRUE;
|
|
}
|
|
|
|
/* FIXME: Pass src_palette generated from lockeddata->PixelFormat. */
|
|
stat = convert_pixels(lockeddata->Width, lockeddata->Height,
|
|
bitmap->stride,
|
|
bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
|
|
bitmap->format, bitmap->image.palette,
|
|
lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
|
|
|
|
if (stat != Ok)
|
|
{
|
|
ERR("failed to convert pixels; this should never happen\n");
|
|
}
|
|
|
|
heap_free(bitmap->bitmapbits);
|
|
bitmap->bitmapbits = NULL;
|
|
bitmap->lockmode = 0;
|
|
|
|
image_unlock(&bitmap->image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
|
|
PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
|
|
{
|
|
Rect area;
|
|
GpStatus stat;
|
|
|
|
TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
|
|
|
|
if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
|
|
x < 0 || y < 0 ||
|
|
x + width > srcBitmap->width || y + height > srcBitmap->height)
|
|
{
|
|
TRACE("<-- InvalidParameter\n");
|
|
return InvalidParameter;
|
|
}
|
|
|
|
if (format == PixelFormatDontCare)
|
|
format = srcBitmap->format;
|
|
|
|
area.X = gdip_round(x);
|
|
area.Y = gdip_round(y);
|
|
area.Width = gdip_round(width);
|
|
area.Height = gdip_round(height);
|
|
|
|
stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
|
|
if (stat == Ok)
|
|
{
|
|
stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
|
|
(*dstBitmap)->image.palette, srcBitmap->stride,
|
|
srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
|
|
srcBitmap->format, srcBitmap->image.palette);
|
|
|
|
if (stat == Ok && srcBitmap->image.palette)
|
|
{
|
|
ColorPalette *src_palette, *dst_palette;
|
|
|
|
src_palette = srcBitmap->image.palette;
|
|
|
|
dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
|
|
|
|
if (dst_palette)
|
|
{
|
|
dst_palette->Flags = src_palette->Flags;
|
|
dst_palette->Count = src_palette->Count;
|
|
memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
|
|
|
|
heap_free((*dstBitmap)->image.palette);
|
|
(*dstBitmap)->image.palette = dst_palette;
|
|
}
|
|
else
|
|
stat = OutOfMemory;
|
|
}
|
|
|
|
if (stat != Ok)
|
|
GdipDisposeImage(&(*dstBitmap)->image);
|
|
}
|
|
|
|
if (stat != Ok)
|
|
*dstBitmap = NULL;
|
|
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
|
|
PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
|
|
{
|
|
TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
|
|
|
|
return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
|
|
{
|
|
TRACE("%p, %p\n", image, cloneImage);
|
|
|
|
if (!image || !cloneImage)
|
|
return InvalidParameter;
|
|
|
|
if (image->type == ImageTypeBitmap)
|
|
{
|
|
GpBitmap *bitmap = (GpBitmap *)image;
|
|
|
|
return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
|
|
bitmap->format, bitmap, (GpBitmap **)cloneImage);
|
|
}
|
|
else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
|
|
{
|
|
GpMetafile *result, *metafile;
|
|
|
|
metafile = (GpMetafile*)image;
|
|
|
|
result = heap_alloc_zero(sizeof(*result));
|
|
if (!result)
|
|
return OutOfMemory;
|
|
|
|
result->image.type = ImageTypeMetafile;
|
|
result->image.format = image->format;
|
|
result->image.flags = image->flags;
|
|
result->image.frame_count = 1;
|
|
result->image.xres = image->xres;
|
|
result->image.yres = image->yres;
|
|
result->bounds = metafile->bounds;
|
|
result->unit = metafile->unit;
|
|
result->metafile_type = metafile->metafile_type;
|
|
result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
|
|
list_init(&result->containers);
|
|
|
|
if (!result->hemf)
|
|
{
|
|
heap_free(result);
|
|
return OutOfMemory;
|
|
}
|
|
|
|
*cloneImage = &result->image;
|
|
return Ok;
|
|
}
|
|
else
|
|
{
|
|
WARN("GpImage with no image data (metafile in wrong state?)\n");
|
|
return InvalidParameter;
|
|
}
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
|
|
GpBitmap **bitmap)
|
|
{
|
|
GpStatus stat;
|
|
IStream *stream;
|
|
|
|
TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
|
|
|
|
if(!filename || !bitmap)
|
|
return InvalidParameter;
|
|
|
|
*bitmap = NULL;
|
|
|
|
stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
|
|
|
|
if(stat != Ok)
|
|
return stat;
|
|
|
|
stat = GdipCreateBitmapFromStream(stream, bitmap);
|
|
|
|
IStream_Release(stream);
|
|
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
|
|
VOID *bits, GpBitmap **bitmap)
|
|
{
|
|
DWORD height, stride;
|
|
HBITMAP hbm;
|
|
void *bmbits;
|
|
GpStatus status;
|
|
|
|
TRACE("(%p, %p, %p)\n", info, bits, bitmap);
|
|
|
|
if (!info || !bits || !bitmap)
|
|
return InvalidParameter;
|
|
|
|
hbm = CreateDIBSection(0, info, DIB_RGB_COLORS, &bmbits, NULL, 0);
|
|
if (!hbm)
|
|
return InvalidParameter;
|
|
|
|
height = abs(info->bmiHeader.biHeight);
|
|
stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
|
|
TRACE("height %lu, stride %lu, image size %lu\n", height, stride, height * stride);
|
|
|
|
memcpy(bmbits, bits, height * stride);
|
|
|
|
status = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
|
|
DeleteObject(hbm);
|
|
|
|
return status;
|
|
}
|
|
|
|
/* FIXME: no icm */
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
|
|
GpBitmap **bitmap)
|
|
{
|
|
TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
|
|
|
|
return GdipCreateBitmapFromFile(filename, bitmap);
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
|
|
GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
|
|
{
|
|
HBITMAP hbm;
|
|
GpStatus stat = InvalidParameter;
|
|
|
|
TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
|
|
|
|
if(!lpBitmapName || !bitmap)
|
|
return InvalidParameter;
|
|
|
|
/* load DIB */
|
|
hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
|
|
LR_CREATEDIBSECTION);
|
|
|
|
if(hbm){
|
|
stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
|
|
DeleteObject(hbm);
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
static inline DWORD blend_argb_no_bkgnd_alpha(DWORD src, DWORD bkgnd)
|
|
{
|
|
BYTE b = (BYTE)src;
|
|
BYTE g = (BYTE)(src >> 8);
|
|
BYTE r = (BYTE)(src >> 16);
|
|
DWORD alpha = (BYTE)(src >> 24);
|
|
return ((b + ((BYTE)bkgnd * (255 - alpha) + 127) / 255) |
|
|
(g + ((BYTE)(bkgnd >> 8) * (255 - alpha) + 127) / 255) << 8 |
|
|
(r + ((BYTE)(bkgnd >> 16) * (255 - alpha) + 127) / 255) << 16 |
|
|
(alpha << 24));
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
|
|
HBITMAP* hbmReturn, ARGB background)
|
|
{
|
|
GpStatus stat;
|
|
HBITMAP result;
|
|
UINT width, height;
|
|
BITMAPINFOHEADER bih;
|
|
LPBYTE bits;
|
|
BOOL unlock;
|
|
|
|
TRACE("(%p,%p,%lx)\n", bitmap, hbmReturn, background);
|
|
|
|
if (!bitmap || !hbmReturn) return InvalidParameter;
|
|
if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
|
|
|
|
GdipGetImageWidth(&bitmap->image, &width);
|
|
GdipGetImageHeight(&bitmap->image, &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;
|
|
|
|
result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
|
|
if (!result)
|
|
{
|
|
image_unlock(&bitmap->image, unlock);
|
|
return GenericError;
|
|
}
|
|
|
|
stat = convert_pixels(width, height, -width*4,
|
|
bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB, bitmap->image.palette,
|
|
bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
|
|
if (stat != Ok)
|
|
{
|
|
DeleteObject(result);
|
|
image_unlock(&bitmap->image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
if (background & 0xffffff)
|
|
{
|
|
DWORD *ptr;
|
|
UINT i;
|
|
for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
|
|
{
|
|
if ((*ptr & 0xff000000) == 0xff000000) continue;
|
|
*ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
|
|
}
|
|
}
|
|
|
|
*hbmReturn = result;
|
|
image_unlock(&bitmap->image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
|
|
GpGraphics* target, GpBitmap** bitmap)
|
|
{
|
|
GpStatus ret;
|
|
|
|
TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
|
|
|
|
if(!target || !bitmap)
|
|
return InvalidParameter;
|
|
|
|
ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
|
|
NULL, bitmap);
|
|
|
|
if (ret == Ok)
|
|
{
|
|
GdipGetDpiX(target, &(*bitmap)->image.xres);
|
|
GdipGetDpiY(target, &(*bitmap)->image.yres);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
|
|
{
|
|
GpStatus stat;
|
|
ICONINFO iinfo;
|
|
BITMAP bm;
|
|
int ret;
|
|
UINT width, height, stride;
|
|
GpRect rect;
|
|
BitmapData lockeddata;
|
|
HDC screendc;
|
|
BOOL has_alpha;
|
|
int x, y;
|
|
BITMAPINFOHEADER bih;
|
|
DWORD *src;
|
|
BYTE *dst_row;
|
|
DWORD *dst;
|
|
|
|
TRACE("%p, %p\n", hicon, bitmap);
|
|
|
|
if(!bitmap || !GetIconInfo(hicon, &iinfo))
|
|
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;
|
|
}
|
|
|
|
width = bm.bmWidth;
|
|
height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
|
|
stride = width * 4;
|
|
|
|
stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
|
|
if (stat != Ok) {
|
|
DeleteObject(iinfo.hbmColor);
|
|
DeleteObject(iinfo.hbmMask);
|
|
return stat;
|
|
}
|
|
|
|
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);
|
|
GdipDisposeImage(&(*bitmap)->image);
|
|
return stat;
|
|
}
|
|
|
|
bih.biSize = sizeof(bih);
|
|
bih.biWidth = width;
|
|
bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
|
|
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 = CreateCompatibleDC(0);
|
|
if (iinfo.hbmColor)
|
|
{
|
|
GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
|
|
|
|
if (bm.bmBitsPixel == 32)
|
|
{
|
|
has_alpha = FALSE;
|
|
|
|
/* If any pixel has a non-zero alpha, ignore hbmMask */
|
|
src = (DWORD*)lockeddata.Scan0;
|
|
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
|
|
{
|
|
GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
|
|
has_alpha = FALSE;
|
|
}
|
|
|
|
if (!has_alpha)
|
|
{
|
|
if (iinfo.hbmMask)
|
|
{
|
|
BYTE *bits = heap_alloc(height * stride);
|
|
|
|
/* 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;
|
|
}
|
|
|
|
heap_free(bits);
|
|
}
|
|
else
|
|
{
|
|
/* set constant alpha of 255 */
|
|
dst_row = lockeddata.Scan0;
|
|
for (y=0; y<height; y++)
|
|
{
|
|
dst = (DWORD*)dst_row;
|
|
for (x=0; x<height; x++)
|
|
*dst++ |= 0xff000000;
|
|
dst_row += lockeddata.Stride;
|
|
}
|
|
}
|
|
}
|
|
|
|
DeleteDC(screendc);
|
|
|
|
DeleteObject(iinfo.hbmColor);
|
|
DeleteObject(iinfo.hbmMask);
|
|
|
|
GdipBitmapUnlockBits(*bitmap, &lockeddata);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
static void generate_halftone_palette(ARGB *entries, UINT count)
|
|
{
|
|
static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
|
|
UINT i;
|
|
|
|
for (i=0; i<8 && i<count; i++)
|
|
{
|
|
entries[i] = 0xff000000;
|
|
if (i&1) entries[i] |= 0x800000;
|
|
if (i&2) entries[i] |= 0x8000;
|
|
if (i&4) entries[i] |= 0x80;
|
|
}
|
|
|
|
if (8 < count)
|
|
entries[i] = 0xffc0c0c0;
|
|
|
|
for (i=9; i<16 && i<count; i++)
|
|
{
|
|
entries[i] = 0xff000000;
|
|
if (i&1) entries[i] |= 0xff0000;
|
|
if (i&2) entries[i] |= 0xff00;
|
|
if (i&4) entries[i] |= 0xff;
|
|
}
|
|
|
|
for (i=16; i<40 && i<count; i++)
|
|
{
|
|
entries[i] = 0;
|
|
}
|
|
|
|
for (i=40; i<256 && i<count; i++)
|
|
{
|
|
entries[i] = 0xff000000;
|
|
entries[i] |= halftone_values[(i-40)%6];
|
|
entries[i] |= halftone_values[((i-40)/6)%6] << 8;
|
|
entries[i] |= halftone_values[((i-40)/36)%6] << 16;
|
|
}
|
|
}
|
|
|
|
static GpStatus get_screen_resolution(REAL *xres, REAL *yres)
|
|
{
|
|
HDC screendc = CreateCompatibleDC(0);
|
|
|
|
if (!screendc) return GenericError;
|
|
|
|
*xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
|
|
*yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
|
|
|
|
DeleteDC(screendc);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
|
|
PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
|
|
{
|
|
HBITMAP hbitmap=NULL;
|
|
INT row_size, dib_stride;
|
|
BYTE *bits=NULL, *own_bits=NULL;
|
|
REAL xres, yres;
|
|
GpStatus stat;
|
|
|
|
TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
|
|
|
|
if (!bitmap) return InvalidParameter;
|
|
|
|
if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
|
|
*bitmap = NULL;
|
|
return InvalidParameter;
|
|
}
|
|
|
|
if(scan0 && !stride)
|
|
return InvalidParameter;
|
|
|
|
stat = get_screen_resolution(&xres, &yres);
|
|
if (stat != Ok) return stat;
|
|
|
|
row_size = (width * PIXELFORMATBPP(format)+7) / 8;
|
|
dib_stride = (row_size + 3) & ~3;
|
|
|
|
if(stride == 0)
|
|
stride = dib_stride;
|
|
|
|
if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
|
|
{
|
|
char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
|
|
BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
|
|
|
|
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
pbmi->bmiHeader.biWidth = width;
|
|
pbmi->bmiHeader.biHeight = -height;
|
|
pbmi->bmiHeader.biPlanes = 1;
|
|
/* FIXME: use the rest of the data from format */
|
|
pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
|
|
pbmi->bmiHeader.biCompression = BI_RGB;
|
|
pbmi->bmiHeader.biSizeImage = 0;
|
|
pbmi->bmiHeader.biXPelsPerMeter = 0;
|
|
pbmi->bmiHeader.biYPelsPerMeter = 0;
|
|
pbmi->bmiHeader.biClrUsed = 0;
|
|
pbmi->bmiHeader.biClrImportant = 0;
|
|
|
|
hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
|
|
|
|
if (!hbitmap) return GenericError;
|
|
|
|
stride = dib_stride;
|
|
}
|
|
else
|
|
{
|
|
/* Not a GDI format; don't try to make an HBITMAP. */
|
|
if (scan0)
|
|
bits = scan0;
|
|
else
|
|
{
|
|
INT size = abs(stride) * height;
|
|
|
|
own_bits = bits = heap_alloc_zero(size);
|
|
if (!own_bits) return OutOfMemory;
|
|
|
|
if (stride < 0)
|
|
bits += stride * (1 - height);
|
|
}
|
|
}
|
|
|
|
*bitmap = heap_alloc_zero(sizeof(GpBitmap));
|
|
if(!*bitmap)
|
|
{
|
|
DeleteObject(hbitmap);
|
|
heap_free(own_bits);
|
|
return OutOfMemory;
|
|
}
|
|
|
|
(*bitmap)->image.type = ImageTypeBitmap;
|
|
memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
|
|
(*bitmap)->image.flags = ImageFlagsNone;
|
|
(*bitmap)->image.frame_count = 1;
|
|
(*bitmap)->image.current_frame = 0;
|
|
(*bitmap)->image.palette = NULL;
|
|
(*bitmap)->image.xres = xres;
|
|
(*bitmap)->image.yres = yres;
|
|
(*bitmap)->width = width;
|
|
(*bitmap)->height = height;
|
|
(*bitmap)->format = format;
|
|
(*bitmap)->image.decoder = NULL;
|
|
(*bitmap)->image.encoder = NULL;
|
|
(*bitmap)->hbitmap = hbitmap;
|
|
(*bitmap)->hdc = NULL;
|
|
(*bitmap)->bits = bits;
|
|
(*bitmap)->stride = stride;
|
|
(*bitmap)->own_bits = own_bits;
|
|
(*bitmap)->metadata_reader = NULL;
|
|
(*bitmap)->prop_count = 0;
|
|
(*bitmap)->prop_item = NULL;
|
|
|
|
/* set format-related flags */
|
|
if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
|
|
(*bitmap)->image.flags |= ImageFlagsHasAlpha;
|
|
|
|
if (format == PixelFormat1bppIndexed ||
|
|
format == PixelFormat4bppIndexed ||
|
|
format == PixelFormat8bppIndexed)
|
|
{
|
|
(*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
|
|
|
|
if (!(*bitmap)->image.palette)
|
|
{
|
|
GdipDisposeImage(&(*bitmap)->image);
|
|
*bitmap = NULL;
|
|
return OutOfMemory;
|
|
}
|
|
|
|
(*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
|
|
|
|
if (format == PixelFormat1bppIndexed)
|
|
{
|
|
(*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
|
|
(*bitmap)->image.palette->Entries[0] = 0xff000000;
|
|
(*bitmap)->image.palette->Entries[1] = 0xffffffff;
|
|
}
|
|
else
|
|
{
|
|
if (format == PixelFormat8bppIndexed)
|
|
(*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
|
|
|
|
generate_halftone_palette((*bitmap)->image.palette->Entries,
|
|
(*bitmap)->image.palette->Count);
|
|
}
|
|
}
|
|
|
|
TRACE("<-- %p\n", *bitmap);
|
|
|
|
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){
|
|
GdipDisposeImage(&(*bitmap)->image);
|
|
*bitmap = NULL;
|
|
return GenericError; /* FIXME: what error to return? */
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/* FIXME: no icm */
|
|
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 = heap_alloc_zero(sizeof(GpCachedBitmap));
|
|
if(!*cachedbmp)
|
|
return OutOfMemory;
|
|
|
|
stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
|
|
if(stat != Ok){
|
|
heap_free(*cachedbmp);
|
|
return stat;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
|
|
{
|
|
GpStatus stat;
|
|
BitmapData lockeddata;
|
|
ULONG andstride, xorstride, bitssize;
|
|
LPBYTE andbits, xorbits, androw, xorrow, srcrow;
|
|
UINT x, y;
|
|
|
|
TRACE("(%p, %p)\n", bitmap, hicon);
|
|
|
|
if (!bitmap || !hicon)
|
|
return InvalidParameter;
|
|
|
|
stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
|
|
PixelFormat32bppPARGB, &lockeddata);
|
|
if (stat == Ok)
|
|
{
|
|
andstride = ((lockeddata.Width+31)/32)*4;
|
|
xorstride = lockeddata.Width*4;
|
|
bitssize = (andstride + xorstride) * lockeddata.Height;
|
|
|
|
andbits = heap_alloc_zero(bitssize);
|
|
|
|
if (andbits)
|
|
{
|
|
xorbits = andbits + andstride * lockeddata.Height;
|
|
|
|
for (y=0; y<lockeddata.Height; y++)
|
|
{
|
|
srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
|
|
|
|
androw = andbits + andstride * y;
|
|
for (x=0; x<lockeddata.Width; x++)
|
|
if (srcrow[3+4*x] >= 128)
|
|
androw[x/8] |= 1 << (7-x%8);
|
|
|
|
xorrow = xorbits + xorstride * y;
|
|
memcpy(xorrow, srcrow, xorstride);
|
|
}
|
|
|
|
*hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
|
|
andbits, xorbits);
|
|
|
|
heap_free(andbits);
|
|
}
|
|
else
|
|
stat = OutOfMemory;
|
|
|
|
GdipBitmapUnlockBits(bitmap, &lockeddata);
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
|
|
{
|
|
TRACE("%p\n", cachedbmp);
|
|
|
|
if(!cachedbmp)
|
|
return InvalidParameter;
|
|
|
|
GdipDisposeImage(cachedbmp->image);
|
|
heap_free(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);
|
|
}
|
|
|
|
/* Internal utility function: Replace the image data of dst with that of src,
|
|
* and free src. */
|
|
static void move_bitmap(GpBitmap *dst, GpBitmap *src, BOOL clobber_palette)
|
|
{
|
|
assert(src->image.type == ImageTypeBitmap);
|
|
assert(dst->image.type == ImageTypeBitmap);
|
|
|
|
heap_free(dst->bitmapbits);
|
|
heap_free(dst->own_bits);
|
|
DeleteDC(dst->hdc);
|
|
DeleteObject(dst->hbitmap);
|
|
|
|
if (clobber_palette)
|
|
{
|
|
heap_free(dst->image.palette);
|
|
dst->image.palette = src->image.palette;
|
|
}
|
|
else
|
|
heap_free(src->image.palette);
|
|
|
|
dst->image.xres = src->image.xres;
|
|
dst->image.yres = src->image.yres;
|
|
dst->width = src->width;
|
|
dst->height = src->height;
|
|
dst->format = src->format;
|
|
dst->hbitmap = src->hbitmap;
|
|
dst->hdc = src->hdc;
|
|
dst->bits = src->bits;
|
|
dst->stride = src->stride;
|
|
dst->own_bits = src->own_bits;
|
|
if (dst->metadata_reader)
|
|
IWICMetadataReader_Release(dst->metadata_reader);
|
|
dst->metadata_reader = src->metadata_reader;
|
|
heap_free(dst->prop_item);
|
|
dst->prop_item = src->prop_item;
|
|
dst->prop_count = src->prop_count;
|
|
if (dst->image.decoder)
|
|
IWICBitmapDecoder_Release(dst->image.decoder);
|
|
dst->image.decoder = src->image.decoder;
|
|
terminate_encoder_wic(&dst->image); /* terminate active encoder before overwriting with src */
|
|
dst->image.encoder = src->image.encoder;
|
|
dst->image.frame_count = src->image.frame_count;
|
|
dst->image.current_frame = src->image.current_frame;
|
|
dst->image.format = src->image.format;
|
|
|
|
src->image.type = ~0;
|
|
heap_free(src);
|
|
}
|
|
|
|
static GpStatus free_image_data(GpImage *image)
|
|
{
|
|
if(!image)
|
|
return InvalidParameter;
|
|
|
|
if (image->type == ImageTypeBitmap)
|
|
{
|
|
heap_free(((GpBitmap*)image)->bitmapbits);
|
|
heap_free(((GpBitmap*)image)->own_bits);
|
|
DeleteDC(((GpBitmap*)image)->hdc);
|
|
DeleteObject(((GpBitmap*)image)->hbitmap);
|
|
if (((GpBitmap*)image)->metadata_reader)
|
|
IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
|
|
heap_free(((GpBitmap*)image)->prop_item);
|
|
}
|
|
else if (image->type == ImageTypeMetafile)
|
|
METAFILE_Free((GpMetafile *)image);
|
|
else
|
|
{
|
|
WARN("invalid image: %p\n", image);
|
|
return ObjectBusy;
|
|
}
|
|
if (image->decoder)
|
|
IWICBitmapDecoder_Release(image->decoder);
|
|
terminate_encoder_wic(image);
|
|
heap_free(image->palette);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
|
|
{
|
|
GpStatus status;
|
|
|
|
TRACE("%p\n", image);
|
|
|
|
status = free_image_data(image);
|
|
if (status != Ok) return status;
|
|
image->type = ~0;
|
|
heap_free(image);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
|
|
{
|
|
static int calls;
|
|
|
|
TRACE("(%p,%p)\n", image, item);
|
|
|
|
if(!image || !item)
|
|
return InvalidParameter;
|
|
|
|
if (!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
|
|
{
|
|
static int calls;
|
|
|
|
TRACE("(%p,%p)\n", image, item);
|
|
|
|
if (!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
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){
|
|
*srcRect = ((GpMetafile*)image)->bounds;
|
|
*srcUnit = ((GpMetafile*)image)->unit;
|
|
}
|
|
else if(image->type == ImageTypeBitmap){
|
|
srcRect->X = srcRect->Y = 0.0;
|
|
srcRect->Width = (REAL) ((GpBitmap*)image)->width;
|
|
srcRect->Height = (REAL) ((GpBitmap*)image)->height;
|
|
*srcUnit = UnitPixel;
|
|
}
|
|
else{
|
|
WARN("GpImage with no image data\n");
|
|
return InvalidParameter;
|
|
}
|
|
|
|
TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
|
|
srcRect->Width, srcRect->Height, *srcUnit);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
|
|
REAL *height)
|
|
{
|
|
TRACE("%p %p %p\n", image, width, height);
|
|
|
|
if(!image || !height || !width)
|
|
return InvalidParameter;
|
|
|
|
if(image->type == ImageTypeMetafile){
|
|
*height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit,
|
|
image->yres, ((GpMetafile*)image)->printer_display);
|
|
*width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit,
|
|
image->xres, ((GpMetafile*)image)->printer_display);
|
|
}
|
|
else if(image->type == ImageTypeBitmap){
|
|
*height = ((GpBitmap*)image)->height;
|
|
*width = ((GpBitmap*)image)->width;
|
|
}
|
|
else{
|
|
WARN("GpImage with no image data\n");
|
|
return InvalidParameter;
|
|
}
|
|
|
|
TRACE("returning (%f, %f)\n", *height, *width);
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
|
|
GpGraphics **graphics)
|
|
{
|
|
HDC hdc;
|
|
GpStatus stat;
|
|
|
|
TRACE("%p %p\n", image, graphics);
|
|
|
|
if(!image || !graphics)
|
|
return InvalidParameter;
|
|
|
|
if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
|
|
{
|
|
hdc = ((GpBitmap*)image)->hdc;
|
|
|
|
if(!hdc){
|
|
hdc = CreateCompatibleDC(0);
|
|
SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
|
|
((GpBitmap*)image)->hdc = hdc;
|
|
}
|
|
|
|
stat = GdipCreateFromHDC(hdc, graphics);
|
|
|
|
if (stat == Ok)
|
|
{
|
|
(*graphics)->image = image;
|
|
(*graphics)->image_type = image->type;
|
|
(*graphics)->xres = image->xres;
|
|
(*graphics)->yres = image->yres;
|
|
}
|
|
}
|
|
else if (image->type == ImageTypeMetafile)
|
|
stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
|
|
else
|
|
stat = graphics_from_image(image, graphics);
|
|
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
|
|
{
|
|
TRACE("%p %p\n", image, height);
|
|
|
|
if(!image || !height)
|
|
return InvalidParameter;
|
|
|
|
if(image->type == ImageTypeMetafile)
|
|
*height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit,
|
|
image->yres, ((GpMetafile*)image)->printer_display);
|
|
else if(image->type == ImageTypeBitmap)
|
|
*height = ((GpBitmap*)image)->height;
|
|
else
|
|
{
|
|
WARN("GpImage with no image data\n");
|
|
return InvalidParameter;
|
|
}
|
|
|
|
TRACE("returning %d\n", *height);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
|
|
{
|
|
if(!image || !res)
|
|
return InvalidParameter;
|
|
|
|
*res = image->xres;
|
|
|
|
TRACE("(%p) <-- %0.2f\n", image, *res);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
|
|
{
|
|
TRACE("%p %p\n", image, size);
|
|
|
|
if(!image || !size)
|
|
return InvalidParameter;
|
|
|
|
if (image->type == ImageTypeMetafile)
|
|
{
|
|
*size = 0;
|
|
return GenericError;
|
|
}
|
|
|
|
if (!image->palette || image->palette->Count == 0)
|
|
*size = sizeof(ColorPalette);
|
|
else
|
|
*size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
|
|
|
|
TRACE("<-- %u\n", *size);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/* 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;
|
|
|
|
if(image->type != ImageTypeBitmap)
|
|
*format = PixelFormat24bppRGB;
|
|
else
|
|
*format = ((GpBitmap*) image)->format;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
|
|
{
|
|
TRACE("(%p, %p)\n", image, format);
|
|
|
|
if(!image || !format)
|
|
return InvalidParameter;
|
|
|
|
memcpy(format, &image->format, sizeof(GUID));
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
|
|
{
|
|
TRACE("%p %p\n", image, type);
|
|
|
|
if(!image || !type)
|
|
return InvalidParameter;
|
|
|
|
*type = image->type;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
|
|
{
|
|
if(!image || !res)
|
|
return InvalidParameter;
|
|
|
|
*res = image->yres;
|
|
|
|
TRACE("(%p) <-- %0.2f\n", image, *res);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
|
|
{
|
|
TRACE("%p %p\n", image, width);
|
|
|
|
if(!image || !width)
|
|
return InvalidParameter;
|
|
|
|
if(image->type == ImageTypeMetafile)
|
|
*width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit,
|
|
image->xres, ((GpMetafile*)image)->printer_display);
|
|
else if(image->type == ImageTypeBitmap)
|
|
*width = ((GpBitmap*)image)->width;
|
|
else
|
|
{
|
|
WARN("GpImage with no image data\n");
|
|
return InvalidParameter;
|
|
}
|
|
|
|
TRACE("returning %d\n", *width);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
|
|
{
|
|
TRACE("(%p, %p)\n", image, num);
|
|
|
|
if (!image || !num) return InvalidParameter;
|
|
|
|
*num = 0;
|
|
|
|
if (image->type == ImageTypeBitmap)
|
|
{
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
*num = ((GpBitmap *)image)->prop_count;
|
|
return Ok;
|
|
}
|
|
|
|
if (((GpBitmap *)image)->metadata_reader)
|
|
IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
|
|
{
|
|
HRESULT hr;
|
|
IWICMetadataReader *reader;
|
|
IWICEnumMetadataItem *enumerator;
|
|
UINT prop_count, i;
|
|
ULONG items_returned;
|
|
|
|
TRACE("(%p, %u, %p)\n", image, num, list);
|
|
|
|
if (!image || !list) return InvalidParameter;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %d\n", image->type);
|
|
return NotImplemented;
|
|
}
|
|
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
|
|
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
list[i] = ((GpBitmap *)image)->prop_item[i].id;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
reader = ((GpBitmap *)image)->metadata_reader;
|
|
if (!reader)
|
|
{
|
|
if (num != 0) return InvalidParameter;
|
|
return Ok;
|
|
}
|
|
|
|
hr = IWICMetadataReader_GetCount(reader, &prop_count);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
if (num != prop_count) return InvalidParameter;
|
|
|
|
hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
IWICEnumMetadataItem_Reset(enumerator);
|
|
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
PROPVARIANT id;
|
|
|
|
hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
|
|
if (hr != S_OK) break;
|
|
|
|
if (id.vt != VT_UI2)
|
|
{
|
|
FIXME("not supported propvariant type for id: %u\n", id.vt);
|
|
list[i] = 0;
|
|
continue;
|
|
}
|
|
list[i] = id.uiVal;
|
|
}
|
|
|
|
IWICEnumMetadataItem_Release(enumerator);
|
|
|
|
return hr == S_OK ? Ok : hresult_to_status(hr);
|
|
}
|
|
|
|
static UINT propvariant_size(PROPVARIANT *value)
|
|
{
|
|
switch (value->vt & ~VT_VECTOR)
|
|
{
|
|
case VT_EMPTY:
|
|
return 0;
|
|
case VT_I1:
|
|
case VT_UI1:
|
|
if (!(value->vt & VT_VECTOR)) return 1;
|
|
return value->caub.cElems;
|
|
case VT_I2:
|
|
case VT_UI2:
|
|
if (!(value->vt & VT_VECTOR)) return 2;
|
|
return value->caui.cElems * 2;
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
case VT_R4:
|
|
if (!(value->vt & VT_VECTOR)) return 4;
|
|
return value->caul.cElems * 4;
|
|
case VT_I8:
|
|
case VT_UI8:
|
|
case VT_R8:
|
|
if (!(value->vt & VT_VECTOR)) return 8;
|
|
return value->cauh.cElems * 8;
|
|
case VT_LPSTR:
|
|
return value->pszVal ? strlen(value->pszVal) + 1 : 0;
|
|
case VT_BLOB:
|
|
return value->blob.cbSize;
|
|
default:
|
|
FIXME("not supported variant type %d\n", value->vt);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
|
|
{
|
|
HRESULT hr;
|
|
IWICMetadataReader *reader;
|
|
PROPVARIANT id, value;
|
|
|
|
TRACE("(%p,%#lx,%p)\n", image, propid, size);
|
|
|
|
if (!size || !image) return InvalidParameter;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %d\n", image->type);
|
|
return NotImplemented;
|
|
}
|
|
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
|
|
{
|
|
if (propid == ((GpBitmap *)image)->prop_item[i].id)
|
|
{
|
|
*size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
|
|
return Ok;
|
|
}
|
|
}
|
|
|
|
return PropertyNotFound;
|
|
}
|
|
|
|
reader = ((GpBitmap *)image)->metadata_reader;
|
|
if (!reader) return PropertyNotFound;
|
|
|
|
id.vt = VT_UI2;
|
|
id.uiVal = propid;
|
|
hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
|
|
if (FAILED(hr)) return PropertyNotFound;
|
|
|
|
*size = propvariant_size(&value);
|
|
if (*size) *size += sizeof(PropertyItem);
|
|
PropVariantClear(&value);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
#ifndef PropertyTagTypeSByte
|
|
#define PropertyTagTypeSByte 6
|
|
#define PropertyTagTypeSShort 8
|
|
#define PropertyTagTypeFloat 11
|
|
#define PropertyTagTypeDouble 12
|
|
#endif
|
|
|
|
static UINT vt_to_itemtype(UINT vt)
|
|
{
|
|
static const struct
|
|
{
|
|
UINT vt, type;
|
|
} vt2type[] =
|
|
{
|
|
{ VT_I1, PropertyTagTypeSByte },
|
|
{ VT_UI1, PropertyTagTypeByte },
|
|
{ VT_I2, PropertyTagTypeSShort },
|
|
{ VT_UI2, PropertyTagTypeShort },
|
|
{ VT_I4, PropertyTagTypeSLONG },
|
|
{ VT_UI4, PropertyTagTypeLong },
|
|
{ VT_I8, PropertyTagTypeSRational },
|
|
{ VT_UI8, PropertyTagTypeRational },
|
|
{ VT_R4, PropertyTagTypeFloat },
|
|
{ VT_R8, PropertyTagTypeDouble },
|
|
{ VT_LPSTR, PropertyTagTypeASCII },
|
|
{ VT_BLOB, PropertyTagTypeUndefined }
|
|
};
|
|
UINT i;
|
|
for (i = 0; i < ARRAY_SIZE(vt2type); i++)
|
|
{
|
|
if (vt2type[i].vt == vt) return vt2type[i].type;
|
|
}
|
|
FIXME("not supported variant type %u\n", vt);
|
|
return 0;
|
|
}
|
|
|
|
static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
|
|
UINT size, PROPID id)
|
|
{
|
|
UINT item_size, item_type;
|
|
|
|
item_size = propvariant_size(value);
|
|
if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
|
|
|
|
item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
|
|
if (!item_type) return InvalidParameter;
|
|
|
|
item->value = item + 1;
|
|
|
|
switch (value->vt & ~VT_VECTOR)
|
|
{
|
|
case VT_I1:
|
|
case VT_UI1:
|
|
if (!(value->vt & VT_VECTOR))
|
|
*(BYTE *)item->value = value->bVal;
|
|
else
|
|
memcpy(item->value, value->caub.pElems, item_size);
|
|
break;
|
|
case VT_I2:
|
|
case VT_UI2:
|
|
if (!(value->vt & VT_VECTOR))
|
|
*(USHORT *)item->value = value->uiVal;
|
|
else
|
|
memcpy(item->value, value->caui.pElems, item_size);
|
|
break;
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
case VT_R4:
|
|
if (!(value->vt & VT_VECTOR))
|
|
*(ULONG *)item->value = value->ulVal;
|
|
else
|
|
memcpy(item->value, value->caul.pElems, item_size);
|
|
break;
|
|
case VT_I8:
|
|
case VT_UI8:
|
|
case VT_R8:
|
|
if (!(value->vt & VT_VECTOR))
|
|
*(ULONGLONG *)item->value = value->uhVal.QuadPart;
|
|
else
|
|
memcpy(item->value, value->cauh.pElems, item_size);
|
|
break;
|
|
case VT_LPSTR:
|
|
memcpy(item->value, value->pszVal, item_size);
|
|
break;
|
|
case VT_BLOB:
|
|
memcpy(item->value, value->blob.pBlobData, item_size);
|
|
break;
|
|
default:
|
|
FIXME("not supported variant type %d\n", value->vt);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
item->length = item_size;
|
|
item->type = item_type;
|
|
item->id = id;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
|
|
PropertyItem *buffer)
|
|
{
|
|
GpStatus stat;
|
|
HRESULT hr;
|
|
IWICMetadataReader *reader;
|
|
PROPVARIANT id, value;
|
|
|
|
TRACE("(%p,%#lx,%u,%p)\n", image, propid, size, buffer);
|
|
|
|
if (!image || !buffer) return InvalidParameter;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %d\n", image->type);
|
|
return NotImplemented;
|
|
}
|
|
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
|
|
{
|
|
if (propid == ((GpBitmap *)image)->prop_item[i].id)
|
|
{
|
|
if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
|
|
return InvalidParameter;
|
|
|
|
*buffer = ((GpBitmap *)image)->prop_item[i];
|
|
buffer->value = buffer + 1;
|
|
memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
|
|
return Ok;
|
|
}
|
|
}
|
|
|
|
return PropertyNotFound;
|
|
}
|
|
|
|
reader = ((GpBitmap *)image)->metadata_reader;
|
|
if (!reader) return PropertyNotFound;
|
|
|
|
id.vt = VT_UI2;
|
|
id.uiVal = propid;
|
|
hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
|
|
if (FAILED(hr)) return PropertyNotFound;
|
|
|
|
stat = propvariant_to_item(&value, buffer, size, propid);
|
|
PropVariantClear(&value);
|
|
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
|
|
{
|
|
HRESULT hr;
|
|
IWICMetadataReader *reader;
|
|
IWICEnumMetadataItem *enumerator;
|
|
UINT prop_count, prop_size, i;
|
|
PROPVARIANT id, value;
|
|
|
|
TRACE("(%p,%p,%p)\n", image, size, count);
|
|
|
|
if (!image || !size || !count) return InvalidParameter;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %d\n", image->type);
|
|
return NotImplemented;
|
|
}
|
|
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
*count = ((GpBitmap *)image)->prop_count;
|
|
*size = 0;
|
|
|
|
for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
|
|
{
|
|
*size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
reader = ((GpBitmap *)image)->metadata_reader;
|
|
if (!reader) return PropertyNotFound;
|
|
|
|
hr = IWICMetadataReader_GetCount(reader, &prop_count);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
IWICEnumMetadataItem_Reset(enumerator);
|
|
|
|
prop_size = 0;
|
|
|
|
PropVariantInit(&id);
|
|
PropVariantInit(&value);
|
|
|
|
for (i = 0; i < prop_count; i++)
|
|
{
|
|
ULONG items_returned;
|
|
UINT item_size;
|
|
|
|
hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
|
|
if (hr != S_OK) break;
|
|
|
|
item_size = propvariant_size(&value);
|
|
if (item_size) prop_size += sizeof(PropertyItem) + item_size;
|
|
|
|
PropVariantClear(&id);
|
|
PropVariantClear(&value);
|
|
}
|
|
|
|
IWICEnumMetadataItem_Release(enumerator);
|
|
|
|
if (hr != S_OK) return PropertyNotFound;
|
|
|
|
*count = prop_count;
|
|
*size = prop_size;
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
|
|
UINT count, PropertyItem *buf)
|
|
{
|
|
GpStatus status;
|
|
HRESULT hr;
|
|
IWICMetadataReader *reader;
|
|
IWICEnumMetadataItem *enumerator;
|
|
UINT prop_count, prop_size, i;
|
|
PROPVARIANT id, value;
|
|
char *item_value;
|
|
|
|
TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
|
|
|
|
if (!image || !buf) return InvalidParameter;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %d\n", image->type);
|
|
return NotImplemented;
|
|
}
|
|
|
|
status = GdipGetPropertySize(image, &prop_size, &prop_count);
|
|
if (status != Ok) return status;
|
|
|
|
if (prop_count != count || prop_size != size) return InvalidParameter;
|
|
|
|
if (((GpBitmap *)image)->prop_item)
|
|
{
|
|
memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
|
|
|
|
item_value = (char *)(buf + prop_count);
|
|
|
|
for (i = 0; i < prop_count; i++)
|
|
{
|
|
buf[i].value = item_value;
|
|
item_value += buf[i].length;
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
reader = ((GpBitmap *)image)->metadata_reader;
|
|
if (!reader) return PropertyNotFound;
|
|
|
|
hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
IWICEnumMetadataItem_Reset(enumerator);
|
|
|
|
item_value = (char *)(buf + prop_count);
|
|
|
|
PropVariantInit(&id);
|
|
PropVariantInit(&value);
|
|
|
|
for (i = 0; i < prop_count; i++)
|
|
{
|
|
PropertyItem *item;
|
|
ULONG items_returned;
|
|
UINT item_size;
|
|
|
|
hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
|
|
if (hr != S_OK) break;
|
|
|
|
if (id.vt != VT_UI2)
|
|
{
|
|
FIXME("not supported propvariant type for id: %u\n", id.vt);
|
|
continue;
|
|
}
|
|
|
|
item_size = propvariant_size(&value);
|
|
if (item_size)
|
|
{
|
|
item = heap_alloc(item_size + sizeof(*item));
|
|
|
|
propvariant_to_item(&value, item, item_size + sizeof(*item), id.uiVal);
|
|
buf[i].id = item->id;
|
|
buf[i].type = item->type;
|
|
buf[i].length = item_size;
|
|
buf[i].value = item_value;
|
|
memcpy(item_value, item->value, item_size);
|
|
item_value += item_size;
|
|
|
|
heap_free(item);
|
|
}
|
|
|
|
PropVariantClear(&id);
|
|
PropVariantClear(&value);
|
|
}
|
|
|
|
IWICEnumMetadataItem_Release(enumerator);
|
|
|
|
if (hr != S_OK) return PropertyNotFound;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
struct image_format_dimension
|
|
{
|
|
const GUID *format;
|
|
const GUID *dimension;
|
|
};
|
|
|
|
static const struct image_format_dimension image_format_dimensions[] =
|
|
{
|
|
{&ImageFormatGIF, &FrameDimensionTime},
|
|
{&ImageFormatIcon, &FrameDimensionResolution},
|
|
{NULL}
|
|
};
|
|
|
|
GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
|
|
GDIPCONST GUID* dimensionID, UINT* count)
|
|
{
|
|
TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
|
|
|
|
if(!image || !count)
|
|
return InvalidParameter;
|
|
|
|
if (!dimensionID ||
|
|
IsEqualGUID(dimensionID, &image->format) ||
|
|
IsEqualGUID(dimensionID, &FrameDimensionPage) ||
|
|
IsEqualGUID(dimensionID, &FrameDimensionTime))
|
|
{
|
|
*count = image->frame_count;
|
|
return Ok;
|
|
}
|
|
|
|
return InvalidParameter;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
|
|
UINT* count)
|
|
{
|
|
TRACE("(%p, %p)\n", image, count);
|
|
|
|
/* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
|
|
|
|
if(!image || !count)
|
|
return InvalidParameter;
|
|
|
|
*count = 1;
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
|
|
GUID* dimensionIDs, UINT count)
|
|
{
|
|
int i;
|
|
const GUID *result=NULL;
|
|
|
|
TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
|
|
|
|
if(!image || !dimensionIDs || count != 1)
|
|
return InvalidParameter;
|
|
|
|
for (i=0; image_format_dimensions[i].format; i++)
|
|
{
|
|
if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
|
|
{
|
|
result = image_format_dimensions[i].dimension;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!result)
|
|
result = &FrameDimensionPage;
|
|
|
|
memcpy(dimensionIDs, result, sizeof(GUID));
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
|
|
GpImage **image)
|
|
{
|
|
GpStatus stat;
|
|
IStream *stream;
|
|
|
|
TRACE("(%s) %p\n", debugstr_w(filename), image);
|
|
|
|
if (!filename || !image)
|
|
return InvalidParameter;
|
|
|
|
*image = NULL;
|
|
|
|
stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
|
|
|
|
if (stat != Ok)
|
|
return stat;
|
|
|
|
stat = GdipLoadImageFromStream(stream, image);
|
|
|
|
IStream_Release(stream);
|
|
|
|
return stat;
|
|
}
|
|
|
|
/* FIXME: no icm handling */
|
|
GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
|
|
{
|
|
TRACE("(%s) %p\n", debugstr_w(filename), image);
|
|
|
|
return GdipLoadImageFromFile(filename, image);
|
|
}
|
|
|
|
static void add_property(GpBitmap *bitmap, PropertyItem *item)
|
|
{
|
|
UINT prop_size, prop_count;
|
|
PropertyItem *prop_item;
|
|
|
|
if (bitmap->prop_item == NULL)
|
|
{
|
|
prop_size = prop_count = 0;
|
|
prop_item = heap_alloc_zero(item->length + sizeof(PropertyItem));
|
|
if (!prop_item) return;
|
|
}
|
|
else
|
|
{
|
|
UINT i;
|
|
char *item_value;
|
|
|
|
GdipGetPropertySize(&bitmap->image, &prop_size, &prop_count);
|
|
|
|
prop_item = heap_alloc_zero(prop_size + item->length + sizeof(PropertyItem));
|
|
if (!prop_item) return;
|
|
memcpy(prop_item, bitmap->prop_item, sizeof(PropertyItem) * bitmap->prop_count);
|
|
prop_size -= sizeof(PropertyItem) * bitmap->prop_count;
|
|
memcpy(prop_item + prop_count + 1, bitmap->prop_item + prop_count, prop_size);
|
|
|
|
item_value = (char *)(prop_item + prop_count + 1);
|
|
|
|
for (i = 0; i < prop_count; i++)
|
|
{
|
|
prop_item[i].value = item_value;
|
|
item_value += prop_item[i].length;
|
|
}
|
|
}
|
|
|
|
prop_item[prop_count].id = item->id;
|
|
prop_item[prop_count].type = item->type;
|
|
prop_item[prop_count].length = item->length;
|
|
prop_item[prop_count].value = (char *)(prop_item + prop_count + 1) + prop_size;
|
|
memcpy(prop_item[prop_count].value, item->value, item->length);
|
|
|
|
heap_free(bitmap->prop_item);
|
|
bitmap->prop_item = prop_item;
|
|
bitmap->prop_count++;
|
|
}
|
|
|
|
static BOOL get_bool_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
|
|
{
|
|
HRESULT hr;
|
|
GUID format;
|
|
PROPVARIANT id, value;
|
|
BOOL ret = FALSE;
|
|
|
|
hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
|
|
if (FAILED(hr) || !IsEqualGUID(&format, guid)) return FALSE;
|
|
|
|
PropVariantInit(&id);
|
|
PropVariantInit(&value);
|
|
|
|
id.vt = VT_LPWSTR;
|
|
id.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
|
|
if (!id.pwszVal) return FALSE;
|
|
lstrcpyW(id.pwszVal, prop_name);
|
|
hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
|
|
if (hr == S_OK && value.vt == VT_BOOL)
|
|
ret = value.boolVal;
|
|
|
|
PropVariantClear(&id);
|
|
PropVariantClear(&value);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static PropertyItem *get_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
|
|
{
|
|
HRESULT hr;
|
|
GUID format;
|
|
PROPVARIANT id, value;
|
|
PropertyItem *item = NULL;
|
|
|
|
hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
|
|
if (FAILED(hr) || !IsEqualGUID(&format, guid)) return NULL;
|
|
|
|
PropVariantInit(&id);
|
|
PropVariantInit(&value);
|
|
|
|
id.vt = VT_LPWSTR;
|
|
id.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
|
|
if (!id.pwszVal) return NULL;
|
|
lstrcpyW(id.pwszVal, prop_name);
|
|
hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
|
|
if (hr == S_OK)
|
|
{
|
|
UINT item_size = propvariant_size(&value);
|
|
if (item_size)
|
|
{
|
|
item_size += sizeof(*item);
|
|
item = heap_alloc_zero(item_size);
|
|
if (propvariant_to_item(&value, item, item_size, 0) != Ok)
|
|
{
|
|
heap_free(item);
|
|
item = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
PropVariantClear(&id);
|
|
PropVariantClear(&value);
|
|
|
|
return item;
|
|
}
|
|
|
|
static PropertyItem *get_gif_comment(IWICMetadataReader *reader)
|
|
{
|
|
PropertyItem *comment;
|
|
|
|
comment = get_property(reader, &GUID_MetadataFormatGifComment, L"TextEntry");
|
|
if (comment)
|
|
comment->id = PropertyTagExifUserComment;
|
|
|
|
return comment;
|
|
}
|
|
|
|
static PropertyItem *get_gif_loopcount(IWICMetadataReader *reader)
|
|
{
|
|
PropertyItem *appext = NULL, *appdata = NULL, *loop = NULL;
|
|
|
|
appext = get_property(reader, &GUID_MetadataFormatAPE, L"Application");
|
|
if (appext)
|
|
{
|
|
if (appext->type == PropertyTagTypeByte && appext->length == 11 &&
|
|
(!memcmp(appext->value, "NETSCAPE2.0", 11) || !memcmp(appext->value, "ANIMEXTS1.0", 11)))
|
|
{
|
|
appdata = get_property(reader, &GUID_MetadataFormatAPE, L"Data");
|
|
if (appdata)
|
|
{
|
|
if (appdata->type == PropertyTagTypeByte && appdata->length == 4)
|
|
{
|
|
BYTE *data = appdata->value;
|
|
if (data[0] == 3 && data[1] == 1)
|
|
{
|
|
loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
|
|
if (loop)
|
|
{
|
|
loop->type = PropertyTagTypeShort;
|
|
loop->id = PropertyTagLoopCount;
|
|
loop->length = sizeof(SHORT);
|
|
loop->value = loop + 1;
|
|
*(SHORT *)loop->value = data[2] | (data[3] << 8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
heap_free(appext);
|
|
heap_free(appdata);
|
|
|
|
return loop;
|
|
}
|
|
|
|
static PropertyItem *get_gif_background(IWICMetadataReader *reader)
|
|
{
|
|
PropertyItem *background;
|
|
|
|
background = get_property(reader, &GUID_MetadataFormatLSD, L"BackgroundColorIndex");
|
|
if (background)
|
|
background->id = PropertyTagIndexBackground;
|
|
|
|
return background;
|
|
}
|
|
|
|
static PropertyItem *get_gif_palette(IWICBitmapDecoder *decoder, IWICMetadataReader *reader)
|
|
{
|
|
HRESULT hr;
|
|
IWICImagingFactory *factory;
|
|
IWICPalette *palette;
|
|
UINT count = 0;
|
|
WICColor colors[256];
|
|
|
|
if (!get_bool_property(reader, &GUID_MetadataFormatLSD, L"GlobalColorTableFlag"))
|
|
return NULL;
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (hr != S_OK) return NULL;
|
|
|
|
hr = IWICImagingFactory_CreatePalette(factory, &palette);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
|
|
if (hr == S_OK)
|
|
IWICPalette_GetColors(palette, 256, colors, &count);
|
|
|
|
IWICPalette_Release(palette);
|
|
}
|
|
|
|
IWICImagingFactory_Release(factory);
|
|
|
|
if (count)
|
|
{
|
|
PropertyItem *pal;
|
|
UINT i;
|
|
BYTE *rgb;
|
|
|
|
pal = heap_alloc_zero(sizeof(*pal) + count * 3);
|
|
if (!pal) return NULL;
|
|
pal->type = PropertyTagTypeByte;
|
|
pal->id = PropertyTagGlobalPalette;
|
|
pal->value = pal + 1;
|
|
pal->length = count * 3;
|
|
|
|
rgb = pal->value;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
rgb[i*3] = (colors[i] >> 16) & 0xff;
|
|
rgb[i*3 + 1] = (colors[i] >> 8) & 0xff;
|
|
rgb[i*3 + 2] = colors[i] & 0xff;
|
|
}
|
|
|
|
return pal;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static PropertyItem *get_gif_transparent_idx(IWICMetadataReader *reader)
|
|
{
|
|
PropertyItem *index = NULL;
|
|
|
|
if (get_bool_property(reader, &GUID_MetadataFormatGCE, L"TransparencyFlag"))
|
|
{
|
|
index = get_property(reader, &GUID_MetadataFormatGCE, L"TransparentColorIndex");
|
|
if (index)
|
|
index->id = PropertyTagIndexTransparent;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
static LONG get_gif_frame_property(IWICBitmapFrameDecode *frame, const GUID *format, const WCHAR *property)
|
|
{
|
|
HRESULT hr;
|
|
IWICMetadataBlockReader *block_reader;
|
|
IWICMetadataReader *reader;
|
|
UINT block_count, i;
|
|
PropertyItem *prop;
|
|
LONG value = 0;
|
|
|
|
hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
|
|
if (hr == S_OK)
|
|
{
|
|
for (i = 0; i < block_count; i++)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
|
|
if (hr == S_OK)
|
|
{
|
|
prop = get_property(reader, format, property);
|
|
if (prop)
|
|
{
|
|
if (prop->type == PropertyTagTypeByte && prop->length == 1)
|
|
value = *(BYTE *)prop->value;
|
|
else if (prop->type == PropertyTagTypeShort && prop->length == 2)
|
|
value = *(SHORT *)prop->value;
|
|
|
|
heap_free(prop);
|
|
}
|
|
IWICMetadataReader_Release(reader);
|
|
}
|
|
}
|
|
}
|
|
IWICMetadataBlockReader_Release(block_reader);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
static void gif_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
|
|
{
|
|
HRESULT hr;
|
|
IWICBitmapFrameDecode *frame;
|
|
IWICMetadataBlockReader *block_reader;
|
|
IWICMetadataReader *reader;
|
|
UINT frame_count, block_count, i;
|
|
PropertyItem *delay = NULL, *comment = NULL, *background = NULL;
|
|
PropertyItem *transparent_idx = NULL, *loop = NULL, *palette = NULL;
|
|
|
|
IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
|
if (frame_count > 1)
|
|
{
|
|
delay = heap_alloc_zero(sizeof(*delay) + frame_count * sizeof(LONG));
|
|
if (delay)
|
|
{
|
|
LONG *value;
|
|
|
|
delay->type = PropertyTagTypeLong;
|
|
delay->id = PropertyTagFrameDelay;
|
|
delay->length = frame_count * sizeof(LONG);
|
|
delay->value = delay + 1;
|
|
|
|
value = delay->value;
|
|
|
|
for (i = 0; i < frame_count; i++)
|
|
{
|
|
hr = IWICBitmapDecoder_GetFrame(decoder, i, &frame);
|
|
if (hr == S_OK)
|
|
{
|
|
value[i] = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, L"Delay");
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
}
|
|
else value[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&block_reader);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
|
|
if (hr == S_OK)
|
|
{
|
|
for (i = 0; i < block_count; i++)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
|
|
if (hr == S_OK)
|
|
{
|
|
if (!comment)
|
|
comment = get_gif_comment(reader);
|
|
|
|
if (frame_count > 1 && !loop)
|
|
loop = get_gif_loopcount(reader);
|
|
|
|
if (!background)
|
|
background = get_gif_background(reader);
|
|
|
|
if (!palette)
|
|
palette = get_gif_palette(decoder, reader);
|
|
|
|
IWICMetadataReader_Release(reader);
|
|
}
|
|
}
|
|
}
|
|
IWICMetadataBlockReader_Release(block_reader);
|
|
}
|
|
|
|
if (frame_count > 1 && !loop)
|
|
{
|
|
loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
|
|
if (loop)
|
|
{
|
|
loop->type = PropertyTagTypeShort;
|
|
loop->id = PropertyTagLoopCount;
|
|
loop->length = sizeof(SHORT);
|
|
loop->value = loop + 1;
|
|
*(SHORT *)loop->value = 1;
|
|
}
|
|
}
|
|
|
|
if (delay) add_property(bitmap, delay);
|
|
if (comment) add_property(bitmap, comment);
|
|
if (loop) add_property(bitmap, loop);
|
|
if (palette) add_property(bitmap, palette);
|
|
if (background) add_property(bitmap, background);
|
|
|
|
heap_free(delay);
|
|
heap_free(comment);
|
|
heap_free(loop);
|
|
heap_free(palette);
|
|
heap_free(background);
|
|
|
|
/* Win7 gdiplus always returns transparent color index from frame 0 */
|
|
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
|
if (hr != S_OK) return;
|
|
|
|
hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
|
|
if (hr == S_OK)
|
|
{
|
|
for (i = 0; i < block_count; i++)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
|
|
if (hr == S_OK)
|
|
{
|
|
if (!transparent_idx)
|
|
transparent_idx = get_gif_transparent_idx(reader);
|
|
|
|
IWICMetadataReader_Release(reader);
|
|
}
|
|
}
|
|
}
|
|
IWICMetadataBlockReader_Release(block_reader);
|
|
}
|
|
|
|
if (transparent_idx) add_property(bitmap, transparent_idx);
|
|
heap_free(transparent_idx);
|
|
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
}
|
|
|
|
static PropertyItem* create_prop(PROPID propid, PROPVARIANT* value)
|
|
{
|
|
PropertyItem *item = NULL;
|
|
UINT item_size = propvariant_size(value);
|
|
|
|
if (item_size)
|
|
{
|
|
item_size += sizeof(*item);
|
|
item = heap_alloc_zero(item_size);
|
|
if (propvariant_to_item(value, item, item_size, propid) != Ok)
|
|
{
|
|
heap_free(item);
|
|
item = NULL;
|
|
}
|
|
}
|
|
|
|
return item;
|
|
}
|
|
|
|
static ULONG get_ulong_by_index(IWICMetadataReader* reader, ULONG index)
|
|
{
|
|
PROPVARIANT value;
|
|
HRESULT hr;
|
|
ULONG result=0;
|
|
|
|
hr = IWICMetadataReader_GetValueByIndex(reader, index, NULL, NULL, &value);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
switch (value.vt)
|
|
{
|
|
case VT_UI4:
|
|
result = value.ulVal;
|
|
break;
|
|
default:
|
|
ERR("unhandled case %u\n", value.vt);
|
|
break;
|
|
}
|
|
PropVariantClear(&value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void png_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
|
|
{
|
|
HRESULT hr;
|
|
IWICBitmapFrameDecode *frame;
|
|
IWICMetadataBlockReader *block_reader;
|
|
IWICMetadataReader *reader;
|
|
UINT block_count, i, j;
|
|
struct keyword_info {
|
|
const char* name;
|
|
PROPID propid;
|
|
BOOL seen;
|
|
} keywords[] = {
|
|
{ "Title", PropertyTagImageTitle },
|
|
{ "Author", PropertyTagArtist },
|
|
{ "Description", PropertyTagImageDescription },
|
|
{ "Copyright", PropertyTagCopyright },
|
|
{ "Software", PropertyTagSoftwareUsed },
|
|
{ "Source", PropertyTagEquipModel },
|
|
{ "Comment", PropertyTagExifUserComment },
|
|
};
|
|
BOOL seen_gamma=FALSE, seen_whitepoint=FALSE, seen_chrm=FALSE;
|
|
|
|
hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
|
|
if (hr != S_OK) return;
|
|
|
|
hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
|
|
if (hr == S_OK)
|
|
{
|
|
for (i = 0; i < block_count; i++)
|
|
{
|
|
hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
|
|
if (hr == S_OK)
|
|
{
|
|
GUID format;
|
|
|
|
hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
|
|
if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunktEXt, &format))
|
|
{
|
|
PROPVARIANT name, value;
|
|
PropertyItem* item;
|
|
|
|
hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &name, &value);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (name.vt == VT_LPSTR)
|
|
{
|
|
for (j = 0; j < ARRAY_SIZE(keywords); j++)
|
|
if (!strcmp(keywords[j].name, name.pszVal))
|
|
break;
|
|
if (j < ARRAY_SIZE(keywords) && !keywords[j].seen)
|
|
{
|
|
keywords[j].seen = TRUE;
|
|
item = create_prop(keywords[j].propid, &value);
|
|
if (item)
|
|
add_property(bitmap, item);
|
|
heap_free(item);
|
|
}
|
|
}
|
|
|
|
PropVariantClear(&name);
|
|
PropVariantClear(&value);
|
|
}
|
|
}
|
|
else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkgAMA, &format))
|
|
{
|
|
PropertyItem* item;
|
|
|
|
if (!seen_gamma)
|
|
{
|
|
item = heap_alloc_zero(sizeof(PropertyItem) + sizeof(ULONG) * 2);
|
|
if (item)
|
|
{
|
|
ULONG *rational;
|
|
item->length = sizeof(ULONG) * 2;
|
|
item->type = PropertyTagTypeRational;
|
|
item->id = PropertyTagGamma;
|
|
rational = item->value = item + 1;
|
|
rational[0] = 100000;
|
|
rational[1] = get_ulong_by_index(reader, 0);
|
|
add_property(bitmap, item);
|
|
seen_gamma = TRUE;
|
|
heap_free(item);
|
|
}
|
|
}
|
|
}
|
|
else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkcHRM, &format))
|
|
{
|
|
PropertyItem* item;
|
|
|
|
if (!seen_whitepoint)
|
|
{
|
|
item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 4);
|
|
if (item)
|
|
{
|
|
ULONG *rational;
|
|
item->length = sizeof(ULONG) * 4;
|
|
item->type = PropertyTagTypeRational;
|
|
item->id = PropertyTagWhitePoint;
|
|
rational = item->value = item + 1;
|
|
rational[0] = get_ulong_by_index(reader, 0);
|
|
rational[1] = 100000;
|
|
rational[2] = get_ulong_by_index(reader, 1);
|
|
rational[3] = 100000;
|
|
add_property(bitmap, item);
|
|
seen_whitepoint = TRUE;
|
|
GdipFree(item);
|
|
}
|
|
}
|
|
if (!seen_chrm)
|
|
{
|
|
item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 12);
|
|
if (item)
|
|
{
|
|
ULONG *rational;
|
|
item->length = sizeof(ULONG) * 12;
|
|
item->type = PropertyTagTypeRational;
|
|
item->id = PropertyTagPrimaryChromaticities;
|
|
rational = item->value = item + 1;
|
|
rational[0] = get_ulong_by_index(reader, 2);
|
|
rational[1] = 100000;
|
|
rational[2] = get_ulong_by_index(reader, 3);
|
|
rational[3] = 100000;
|
|
rational[4] = get_ulong_by_index(reader, 4);
|
|
rational[5] = 100000;
|
|
rational[6] = get_ulong_by_index(reader, 5);
|
|
rational[7] = 100000;
|
|
rational[8] = get_ulong_by_index(reader, 6);
|
|
rational[9] = 100000;
|
|
rational[10] = get_ulong_by_index(reader, 7);
|
|
rational[11] = 100000;
|
|
add_property(bitmap, item);
|
|
seen_chrm = TRUE;
|
|
GdipFree(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
IWICMetadataReader_Release(reader);
|
|
}
|
|
}
|
|
}
|
|
IWICMetadataBlockReader_Release(block_reader);
|
|
}
|
|
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
}
|
|
|
|
static GpStatus initialize_decoder_wic(IStream *stream, REFGUID container, IWICBitmapDecoder **decoder)
|
|
{
|
|
IWICImagingFactory *factory;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p,%s\n", stream, wine_dbgstr_guid(container));
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
hr = IWICImagingFactory_CreateDecoder(factory, container, NULL, decoder);
|
|
IWICImagingFactory_Release(factory);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
hr = IWICBitmapDecoder_Initialize(*decoder, stream, WICDecodeMetadataCacheOnLoad);
|
|
if (FAILED(hr))
|
|
{
|
|
IWICBitmapDecoder_Release(*decoder);
|
|
return hresult_to_status(hr);
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
typedef void (*metadata_reader_func)(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT frame);
|
|
|
|
static GpStatus decode_frame_wic(IWICBitmapDecoder *decoder, BOOL force_conversion,
|
|
UINT active_frame, metadata_reader_func metadata_reader, GpImage **image)
|
|
{
|
|
GpStatus status=Ok;
|
|
GpBitmap *bitmap;
|
|
HRESULT hr;
|
|
IWICBitmapFrameDecode *frame;
|
|
IWICBitmapSource *source=NULL;
|
|
IWICMetadataBlockReader *block_reader;
|
|
WICPixelFormatGUID wic_format;
|
|
PixelFormat gdip_format=0;
|
|
ColorPalette *palette = NULL;
|
|
WICBitmapPaletteType palette_type = WICBitmapPaletteTypeFixedHalftone256;
|
|
int i;
|
|
UINT width, height, frame_count;
|
|
BitmapData lockeddata;
|
|
WICRect wrc;
|
|
|
|
TRACE("%p,%u,%p\n", decoder, active_frame, image);
|
|
|
|
IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
|
hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
|
|
if (SUCCEEDED(hr)) /* got frame */
|
|
{
|
|
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!force_conversion)
|
|
{
|
|
for (i=0; pixel_formats[i].wic_format; i++)
|
|
{
|
|
if (IsEqualGUID(&wic_format, pixel_formats[i].wic_format))
|
|
{
|
|
source = (IWICBitmapSource*)frame;
|
|
IWICBitmapSource_AddRef(source);
|
|
gdip_format = pixel_formats[i].gdip_format;
|
|
palette_type = pixel_formats[i].palette_type;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!source)
|
|
{
|
|
/* unknown format; fall back on 32bppARGB */
|
|
hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
|
|
gdip_format = PixelFormat32bppARGB;
|
|
}
|
|
TRACE("%s => %#x\n", wine_dbgstr_guid(&wic_format), gdip_format);
|
|
}
|
|
|
|
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 = &bitmap->image;
|
|
else
|
|
{
|
|
*image = NULL;
|
|
GdipDisposeImage(&bitmap->image);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && status == Ok)
|
|
{
|
|
double dpix, dpiy;
|
|
hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
bitmap->image.xres = dpix;
|
|
bitmap->image.yres = dpiy;
|
|
}
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
IWICBitmapSource_Release(source);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && status == Ok) {
|
|
bitmap->metadata_reader = NULL;
|
|
|
|
if (metadata_reader)
|
|
metadata_reader(bitmap, decoder, active_frame);
|
|
else if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
|
|
{
|
|
UINT block_count = 0;
|
|
if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
|
|
IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
|
|
IWICMetadataBlockReader_Release(block_reader);
|
|
}
|
|
|
|
palette = get_palette(frame, palette_type);
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
|
|
|
|
if (status == Ok)
|
|
{
|
|
/* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
|
|
bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI;
|
|
if (IsEqualGUID(&wic_format, &GUID_WICPixelFormat2bppGray) ||
|
|
IsEqualGUID(&wic_format, &GUID_WICPixelFormat4bppGray) ||
|
|
IsEqualGUID(&wic_format, &GUID_WICPixelFormat8bppGray) ||
|
|
IsEqualGUID(&wic_format, &GUID_WICPixelFormat16bppGray))
|
|
bitmap->image.flags |= ImageFlagsColorSpaceGRAY;
|
|
else
|
|
bitmap->image.flags |= ImageFlagsColorSpaceRGB;
|
|
bitmap->image.frame_count = frame_count;
|
|
bitmap->image.current_frame = active_frame;
|
|
bitmap->image.decoder = decoder;
|
|
IWICBitmapDecoder_AddRef(decoder);
|
|
if (palette)
|
|
{
|
|
heap_free(bitmap->image.palette);
|
|
bitmap->image.palette = palette;
|
|
}
|
|
else
|
|
{
|
|
if (IsEqualGUID(&wic_format, &GUID_WICPixelFormatBlackWhite))
|
|
bitmap->image.palette->Flags = 0;
|
|
}
|
|
TRACE("=> %p\n", *image);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static GpStatus decode_image_wic(IStream *stream, REFGUID container,
|
|
metadata_reader_func metadata_reader, GpImage **image)
|
|
{
|
|
IWICBitmapDecoder *decoder;
|
|
GpStatus status;
|
|
|
|
status = initialize_decoder_wic(stream, container, &decoder);
|
|
if(status != Ok)
|
|
return status;
|
|
|
|
status = decode_frame_wic(decoder, FALSE, 0, metadata_reader, image);
|
|
IWICBitmapDecoder_Release(decoder);
|
|
return status;
|
|
}
|
|
|
|
static GpStatus select_frame_wic(GpImage *image, UINT active_frame)
|
|
{
|
|
GpImage *new_image;
|
|
GpStatus status;
|
|
|
|
status = decode_frame_wic(image->decoder, FALSE, active_frame, NULL, &new_image);
|
|
if(status != Ok)
|
|
return status;
|
|
|
|
new_image->busy = image->busy;
|
|
memcpy(&new_image->format, &image->format, sizeof(GUID));
|
|
new_image->encoder = image->encoder;
|
|
image->encoder = NULL;
|
|
free_image_data(image);
|
|
if (image->type == ImageTypeBitmap)
|
|
*(GpBitmap *)image = *(GpBitmap *)new_image;
|
|
else if (image->type == ImageTypeMetafile)
|
|
*(GpMetafile *)image = *(GpMetafile *)new_image;
|
|
new_image->type = ~0;
|
|
heap_free(new_image);
|
|
return Ok;
|
|
}
|
|
|
|
static HRESULT get_gif_frame_rect(IWICBitmapFrameDecode *frame,
|
|
UINT *left, UINT *top, UINT *width, UINT *height)
|
|
{
|
|
*left = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, L"Left");
|
|
*top = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, L"Top");
|
|
|
|
return IWICBitmapFrameDecode_GetSize(frame, width, height);
|
|
}
|
|
|
|
static HRESULT blit_gif_frame(GpBitmap *bitmap, IWICBitmapFrameDecode *frame, BOOL first_frame)
|
|
{
|
|
UINT i, j, left, top, width, height;
|
|
IWICBitmapSource *source;
|
|
BYTE *new_bits;
|
|
HRESULT hr;
|
|
|
|
hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
|
|
hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
|
|
if(FAILED(hr))
|
|
return hr;
|
|
|
|
new_bits = heap_alloc_zero(width*height*4);
|
|
if(!new_bits)
|
|
return E_OUTOFMEMORY;
|
|
|
|
hr = IWICBitmapSource_CopyPixels(source, NULL, width*4, width*height*4, new_bits);
|
|
IWICBitmapSource_Release(source);
|
|
if(FAILED(hr)) {
|
|
heap_free(new_bits);
|
|
return hr;
|
|
}
|
|
|
|
for(i=0; i<height && i+top<bitmap->height; i++) {
|
|
for(j=0; j<width && j+left<bitmap->width; j++) {
|
|
DWORD *src = (DWORD*)(new_bits+i*width*4+j*4);
|
|
DWORD *dst = (DWORD*)(bitmap->bits+(i+top)*bitmap->stride+(j+left)*4);
|
|
|
|
if(first_frame || *src>>24 != 0)
|
|
*dst = *src;
|
|
}
|
|
}
|
|
heap_free(new_bits);
|
|
return hr;
|
|
}
|
|
|
|
static DWORD get_gif_background_color(GpBitmap *bitmap)
|
|
{
|
|
BYTE bgcolor_idx = 0;
|
|
UINT i;
|
|
|
|
for(i=0; i<bitmap->prop_count; i++) {
|
|
if(bitmap->prop_item[i].id == PropertyTagIndexBackground) {
|
|
bgcolor_idx = *(BYTE*)bitmap->prop_item[i].value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(i=0; i<bitmap->prop_count; i++) {
|
|
if(bitmap->prop_item[i].id == PropertyTagIndexTransparent) {
|
|
BYTE transparent_idx;
|
|
transparent_idx = *(BYTE*)bitmap->prop_item[i].value;
|
|
|
|
if(transparent_idx == bgcolor_idx)
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for(i=0; i<bitmap->prop_count; i++) {
|
|
if(bitmap->prop_item[i].id == PropertyTagGlobalPalette) {
|
|
if(bitmap->prop_item[i].length/3 > bgcolor_idx) {
|
|
BYTE *color = ((BYTE*)bitmap->prop_item[i].value)+bgcolor_idx*3;
|
|
return color[2] + (color[1]<<8) + (color[0]<<16) + (0xffu<<24);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
FIXME("can't get gif background color\n");
|
|
return 0xffffffff;
|
|
}
|
|
|
|
static GpStatus select_frame_gif(GpImage* image, UINT active_frame)
|
|
{
|
|
GpBitmap *bitmap = (GpBitmap*)image;
|
|
IWICBitmapFrameDecode *frame;
|
|
int cur_frame=0, disposal;
|
|
BOOL bgcolor_set = FALSE;
|
|
DWORD bgcolor = 0;
|
|
HRESULT hr;
|
|
|
|
if(active_frame > image->current_frame) {
|
|
hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, image->current_frame, &frame);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, L"Disposal");
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
|
|
if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND)
|
|
cur_frame = image->current_frame;
|
|
else if(disposal != GIF_DISPOSE_RESTORE_TO_PREV)
|
|
cur_frame = image->current_frame+1;
|
|
}
|
|
|
|
while(cur_frame != active_frame) {
|
|
hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, cur_frame, &frame);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, L"Disposal");
|
|
|
|
if(disposal==GIF_DISPOSE_UNSPECIFIED || disposal==GIF_DISPOSE_DO_NOT_DISPOSE) {
|
|
hr = blit_gif_frame(bitmap, frame, cur_frame==0);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
}else if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND) {
|
|
UINT left, top, width, height, i, j;
|
|
|
|
if(!bgcolor_set) {
|
|
bgcolor = get_gif_background_color(bitmap);
|
|
bgcolor_set = TRUE;
|
|
}
|
|
|
|
hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
for(i=top; i<top+height && i<bitmap->height; i++) {
|
|
DWORD *bits = (DWORD*)(bitmap->bits+i*bitmap->stride);
|
|
for(j=left; j<left+width && j<bitmap->width; j++)
|
|
bits[j] = bgcolor;
|
|
}
|
|
}
|
|
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
cur_frame++;
|
|
}
|
|
|
|
hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, active_frame, &frame);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
|
|
hr = blit_gif_frame(bitmap, frame, cur_frame==0);
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
|
|
image->current_frame = active_frame;
|
|
return Ok;
|
|
}
|
|
|
|
static GpStatus decode_image_icon(IStream* stream, GpImage **image)
|
|
{
|
|
return decode_image_wic(stream, &GUID_ContainerFormatIco, NULL, image);
|
|
}
|
|
|
|
static GpStatus decode_image_bmp(IStream* stream, GpImage **image)
|
|
{
|
|
GpStatus status;
|
|
GpBitmap* bitmap;
|
|
|
|
status = decode_image_wic(stream, &GUID_ContainerFormatBmp, NULL, 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, GpImage **image)
|
|
{
|
|
return decode_image_wic(stream, &GUID_ContainerFormatJpeg, NULL, image);
|
|
}
|
|
|
|
static BOOL has_png_transparency_chunk(IStream *pIStream)
|
|
{
|
|
LARGE_INTEGER seek;
|
|
BOOL has_tRNS = FALSE;
|
|
HRESULT hr;
|
|
BYTE header[8];
|
|
|
|
seek.QuadPart = 8;
|
|
do
|
|
{
|
|
ULARGE_INTEGER chunk_start;
|
|
ULONG bytesread, chunk_size;
|
|
|
|
hr = IStream_Seek(pIStream, seek, STREAM_SEEK_SET, &chunk_start);
|
|
if (FAILED(hr)) break;
|
|
|
|
hr = IStream_Read(pIStream, header, 8, &bytesread);
|
|
if (FAILED(hr) || bytesread < 8) break;
|
|
|
|
chunk_size = (header[0] << 24) | (header[1] << 16) | (header[2] << 8) | header[3];
|
|
if (!memcmp(&header[4], "tRNS", 4))
|
|
{
|
|
has_tRNS = TRUE;
|
|
break;
|
|
}
|
|
|
|
seek.QuadPart = chunk_start.QuadPart + chunk_size + 12; /* skip data and CRC */
|
|
} while (memcmp(&header[4], "IDAT", 4) && memcmp(&header[4], "IEND", 4));
|
|
|
|
TRACE("has_tRNS = %d\n", has_tRNS);
|
|
return has_tRNS;
|
|
}
|
|
|
|
static GpStatus decode_image_png(IStream* stream, GpImage **image)
|
|
{
|
|
IWICBitmapDecoder *decoder;
|
|
IWICBitmapFrameDecode *frame;
|
|
GpStatus status;
|
|
HRESULT hr;
|
|
GUID format;
|
|
BOOL force_conversion = FALSE;
|
|
|
|
status = initialize_decoder_wic(stream, &GUID_ContainerFormatPng, &decoder);
|
|
if (status != Ok)
|
|
return status;
|
|
|
|
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
|
|
if (hr == S_OK)
|
|
{
|
|
if (IsEqualGUID(&format, &GUID_WICPixelFormat8bppGray))
|
|
force_conversion = TRUE;
|
|
else if ((IsEqualGUID(&format, &GUID_WICPixelFormat8bppIndexed) ||
|
|
IsEqualGUID(&format, &GUID_WICPixelFormat4bppIndexed) ||
|
|
IsEqualGUID(&format, &GUID_WICPixelFormat2bppIndexed) ||
|
|
IsEqualGUID(&format, &GUID_WICPixelFormat1bppIndexed) ||
|
|
IsEqualGUID(&format, &GUID_WICPixelFormat24bppBGR)) &&
|
|
has_png_transparency_chunk(stream))
|
|
force_conversion = TRUE;
|
|
|
|
status = decode_frame_wic(decoder, force_conversion, 0, png_metadata_reader, image);
|
|
}
|
|
else
|
|
status = hresult_to_status(hr);
|
|
|
|
IWICBitmapFrameDecode_Release(frame);
|
|
}
|
|
else
|
|
status = hresult_to_status(hr);
|
|
|
|
IWICBitmapDecoder_Release(decoder);
|
|
return status;
|
|
}
|
|
|
|
static GpStatus decode_image_gif(IStream* stream, GpImage **image)
|
|
{
|
|
IWICBitmapDecoder *decoder;
|
|
UINT frame_count;
|
|
GpStatus status;
|
|
HRESULT hr;
|
|
|
|
status = initialize_decoder_wic(stream, &GUID_ContainerFormatGif, &decoder);
|
|
if(status != Ok)
|
|
return status;
|
|
|
|
hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
|
|
if(FAILED(hr))
|
|
return hresult_to_status(hr);
|
|
|
|
status = decode_frame_wic(decoder, frame_count > 1, 0, gif_metadata_reader, image);
|
|
IWICBitmapDecoder_Release(decoder);
|
|
if(status != Ok)
|
|
return status;
|
|
|
|
if(frame_count > 1) {
|
|
heap_free((*image)->palette);
|
|
(*image)->palette = NULL;
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
static GpStatus decode_image_tiff(IStream* stream, GpImage **image)
|
|
{
|
|
return decode_image_wic(stream, &GUID_ContainerFormatTiff, NULL, image);
|
|
}
|
|
|
|
C_ASSERT(offsetof(WmfPlaceableFileHeader, Key) == 0);
|
|
|
|
static GpStatus load_wmf(IStream *stream, GpMetafile **metafile)
|
|
{
|
|
WmfPlaceableFileHeader pfh;
|
|
BOOL is_placeable = FALSE;
|
|
LARGE_INTEGER seek;
|
|
GpStatus status;
|
|
METAHEADER mh;
|
|
HMETAFILE hmf;
|
|
HRESULT hr;
|
|
ULONG size;
|
|
void *buf;
|
|
|
|
hr = IStream_Read(stream, &mh, sizeof(mh), &size);
|
|
if (hr != S_OK || size != sizeof(mh))
|
|
return GenericError;
|
|
|
|
/* detect whether stream starts with a WmfPlaceablefileheader */
|
|
if (*(UINT32 *)&mh == WMF_PLACEABLE_KEY)
|
|
{
|
|
seek.QuadPart = 0;
|
|
hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
hr = IStream_Read(stream, &pfh, sizeof(pfh), &size);
|
|
if (hr != S_OK || size != sizeof(pfh))
|
|
return GenericError;
|
|
|
|
hr = IStream_Read(stream, &mh, sizeof(mh), &size);
|
|
if (hr != S_OK || size != sizeof(mh))
|
|
return GenericError;
|
|
|
|
is_placeable = TRUE;
|
|
}
|
|
|
|
seek.QuadPart = is_placeable ? sizeof(pfh) : 0;
|
|
hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
buf = heap_alloc(mh.mtSize * 2);
|
|
if (!buf) return OutOfMemory;
|
|
|
|
hr = IStream_Read(stream, buf, mh.mtSize * 2, &size);
|
|
if (hr != S_OK || size != mh.mtSize * 2)
|
|
{
|
|
heap_free(buf);
|
|
return GenericError;
|
|
}
|
|
|
|
hmf = SetMetaFileBitsEx(mh.mtSize * 2, buf);
|
|
heap_free(buf);
|
|
if (!hmf)
|
|
return GenericError;
|
|
|
|
status = GdipCreateMetafileFromWmf(hmf, TRUE, is_placeable ? &pfh : NULL, metafile);
|
|
if (status != Ok)
|
|
DeleteMetaFile(hmf);
|
|
return status;
|
|
}
|
|
|
|
static GpStatus decode_image_wmf(IStream *stream, GpImage **image)
|
|
{
|
|
GpMetafile *metafile;
|
|
GpStatus status;
|
|
|
|
TRACE("%p %p\n", stream, image);
|
|
|
|
if (!stream || !image)
|
|
return InvalidParameter;
|
|
|
|
status = load_wmf(stream, &metafile);
|
|
if (status != Ok)
|
|
{
|
|
TRACE("Could not load metafile\n");
|
|
return status;
|
|
}
|
|
|
|
*image = (GpImage *)metafile;
|
|
TRACE("<-- %p\n", *image);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
static GpStatus load_emf(IStream *stream, GpMetafile **metafile)
|
|
{
|
|
LARGE_INTEGER seek;
|
|
ENHMETAHEADER emh;
|
|
HENHMETAFILE hemf;
|
|
GpStatus status;
|
|
HRESULT hr;
|
|
ULONG size;
|
|
void *buf;
|
|
|
|
hr = IStream_Read(stream, &emh, sizeof(emh), &size);
|
|
if (hr != S_OK || size != sizeof(emh) || emh.dSignature != ENHMETA_SIGNATURE)
|
|
return GenericError;
|
|
|
|
seek.QuadPart = 0;
|
|
hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
|
|
buf = heap_alloc(emh.nBytes);
|
|
if (!buf) return OutOfMemory;
|
|
|
|
hr = IStream_Read(stream, buf, emh.nBytes, &size);
|
|
if (hr != S_OK || size != emh.nBytes)
|
|
{
|
|
heap_free(buf);
|
|
return GenericError;
|
|
}
|
|
|
|
hemf = SetEnhMetaFileBits(emh.nBytes, buf);
|
|
heap_free(buf);
|
|
if (!hemf)
|
|
return GenericError;
|
|
|
|
status = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
|
|
if (status != Ok)
|
|
DeleteEnhMetaFile(hemf);
|
|
return status;
|
|
}
|
|
|
|
static GpStatus decode_image_emf(IStream *stream, GpImage **image)
|
|
{
|
|
GpMetafile *metafile;
|
|
GpStatus status;
|
|
|
|
TRACE("%p %p\n", stream, image);
|
|
|
|
if (!stream || !image)
|
|
return InvalidParameter;
|
|
|
|
status = load_emf(stream, &metafile);
|
|
if (status != Ok)
|
|
{
|
|
TRACE("Could not load metafile\n");
|
|
return status;
|
|
}
|
|
|
|
*image = (GpImage *)metafile;
|
|
TRACE("<-- %p\n", *image);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params);
|
|
|
|
typedef GpStatus (*decode_image_func)(IStream *stream, GpImage **image);
|
|
|
|
typedef GpStatus (*select_image_func)(GpImage *image, UINT active_frame);
|
|
|
|
typedef struct image_codec {
|
|
ImageCodecInfo info;
|
|
encode_image_func encode_func;
|
|
decode_image_func decode_func;
|
|
select_image_func select_func;
|
|
} image_codec;
|
|
|
|
typedef enum {
|
|
BMP,
|
|
JPEG,
|
|
GIF,
|
|
TIFF,
|
|
EMF,
|
|
WMF,
|
|
PNG,
|
|
ICO,
|
|
NUM_CODECS
|
|
} ImageFormat;
|
|
|
|
static const struct image_codec codecs[NUM_CODECS];
|
|
|
|
static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
|
|
{
|
|
BYTE signature[8];
|
|
const BYTE *pattern, *mask;
|
|
LARGE_INTEGER seek;
|
|
HRESULT hr;
|
|
ULONG bytesread;
|
|
int i;
|
|
DWORD j, sig;
|
|
|
|
/* 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 signatures <= 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 (sig=0; sig<codecs[i].info.SigCount; sig++)
|
|
{
|
|
pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
|
|
mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
|
|
for (j=0; j<codecs[i].info.SigSize; j++)
|
|
if ((signature[j] & mask[j]) != pattern[j])
|
|
break;
|
|
if (j == codecs[i].info.SigSize)
|
|
{
|
|
*result = &codecs[i];
|
|
return Ok;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE("no match for %lu 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 GenericError;
|
|
}
|
|
|
|
static GpStatus get_decoder_info_from_image(GpImage *image, const struct image_codec **result)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < NUM_CODECS; i++) {
|
|
if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
|
|
IsEqualIID(&codecs[i].info.FormatID, &image->format))
|
|
{
|
|
*result = &codecs[i];
|
|
return Ok;
|
|
}
|
|
}
|
|
|
|
TRACE("no match for format: %s\n", wine_dbgstr_guid(&image->format));
|
|
return GenericError;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
|
|
UINT frame)
|
|
{
|
|
GpStatus stat;
|
|
const struct image_codec *codec = NULL;
|
|
BOOL unlock;
|
|
|
|
TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
|
|
|
|
if (!image || !dimensionID)
|
|
return InvalidParameter;
|
|
if(!image_lock(image, &unlock))
|
|
return ObjectBusy;
|
|
|
|
if (frame >= image->frame_count)
|
|
{
|
|
WARN("requested frame %u, but image has only %u\n", frame, image->frame_count);
|
|
image_unlock(image, unlock);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
|
|
{
|
|
WARN("invalid image type %d\n", image->type);
|
|
image_unlock(image, unlock);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
if (image->current_frame == frame)
|
|
{
|
|
image_unlock(image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
if (!image->decoder)
|
|
{
|
|
TRACE("image doesn't have an associated decoder\n");
|
|
image_unlock(image, unlock);
|
|
return Ok;
|
|
}
|
|
|
|
/* choose an appropriate image decoder */
|
|
stat = get_decoder_info_from_image(image, &codec);
|
|
if (stat != Ok)
|
|
{
|
|
WARN("can't find decoder info\n");
|
|
image_unlock(image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
stat = codec->select_func(image, frame);
|
|
image_unlock(image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
|
|
{
|
|
GpStatus stat;
|
|
LARGE_INTEGER seek;
|
|
HRESULT hr;
|
|
const struct image_codec *codec=NULL;
|
|
|
|
TRACE("%p %p\n", stream, image);
|
|
|
|
if (!stream || !image)
|
|
return InvalidParameter;
|
|
|
|
/* 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, image);
|
|
|
|
/* take note of the original data format */
|
|
if (stat == Ok)
|
|
{
|
|
memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
|
|
return Ok;
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
/* FIXME: no ICM */
|
|
GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
|
|
{
|
|
TRACE("%p %p\n", stream, image);
|
|
|
|
return GdipLoadImageFromStream(stream, image);
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
|
|
{
|
|
static int calls;
|
|
|
|
TRACE("(%p,%lu)\n", image, propId);
|
|
|
|
if(!image)
|
|
return InvalidParameter;
|
|
|
|
if(!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
|
|
{
|
|
static int calls;
|
|
|
|
if (!image || !item) return InvalidParameter;
|
|
|
|
TRACE("(%p,%p:%#lx,%u,%lu,%p)\n", image, item, item->id, item->type, item->length, item->value);
|
|
|
|
if(!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
|
|
GDIPCONST CLSID *clsidEncoder,
|
|
GDIPCONST EncoderParameters *encoderParams)
|
|
{
|
|
GpStatus stat;
|
|
IStream *stream;
|
|
|
|
TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
|
|
|
|
if (!image || !filename|| !clsidEncoder)
|
|
return InvalidParameter;
|
|
|
|
/* this might release an old file stream held by the encoder so we can re-create it below */
|
|
terminate_encoder_wic(image);
|
|
|
|
stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
|
|
if (stat != Ok)
|
|
return GenericError;
|
|
|
|
stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
|
|
|
|
IStream_Release(stream);
|
|
return stat;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* Encoding functions -
|
|
* These functions encode an image in different image file formats.
|
|
*/
|
|
|
|
static GpStatus initialize_encoder_wic(IStream *stream, REFGUID container, GpImage *image)
|
|
{
|
|
IWICImagingFactory *factory;
|
|
HRESULT hr;
|
|
|
|
TRACE("%p,%s\n", stream, wine_dbgstr_guid(container));
|
|
|
|
terminate_encoder_wic(image); /* terminate previous encoder if it exists */
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (FAILED(hr)) return hresult_to_status(hr);
|
|
hr = IWICImagingFactory_CreateEncoder(factory, container, NULL, &image->encoder);
|
|
IWICImagingFactory_Release(factory);
|
|
if (FAILED(hr))
|
|
{
|
|
image->encoder = NULL;
|
|
return hresult_to_status(hr);
|
|
}
|
|
|
|
hr = IWICBitmapEncoder_Initialize(image->encoder, stream, WICBitmapEncoderNoCache);
|
|
if (FAILED(hr))
|
|
{
|
|
IWICBitmapEncoder_Release(image->encoder);
|
|
image->encoder = NULL;
|
|
return hresult_to_status(hr);
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
GpStatus terminate_encoder_wic(GpImage *image)
|
|
{
|
|
if (!image->encoder)
|
|
return Ok;
|
|
else
|
|
{
|
|
HRESULT hr = IWICBitmapEncoder_Commit(image->encoder);
|
|
IWICBitmapEncoder_Release(image->encoder);
|
|
image->encoder = NULL;
|
|
return hresult_to_status(hr);
|
|
}
|
|
}
|
|
|
|
static GpStatus encode_frame_wic(IWICBitmapEncoder *encoder, GpImage *image)
|
|
{
|
|
GpStatus stat;
|
|
GpBitmap *bitmap;
|
|
IWICBitmapFrameEncode *frameencode;
|
|
IPropertyBag2 *encoderoptions;
|
|
GUID container_format;
|
|
HRESULT hr;
|
|
UINT width, height;
|
|
PixelFormat gdipformat=0;
|
|
const WICPixelFormatGUID *desired_wicformat;
|
|
WICPixelFormatGUID wicformat;
|
|
GpRect rc;
|
|
BitmapData lockeddata;
|
|
UINT i;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
return GenericError;
|
|
|
|
bitmap = (GpBitmap*)image;
|
|
|
|
GdipGetImageWidth(image, &width);
|
|
GdipGetImageHeight(image, &height);
|
|
|
|
rc.X = 0;
|
|
rc.Y = 0;
|
|
rc.Width = width;
|
|
rc.Height = height;
|
|
|
|
hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
|
|
|
|
if (SUCCEEDED(hr)) /* created frame */
|
|
{
|
|
hr = IWICBitmapEncoder_GetContainerFormat(encoder, &container_format);
|
|
if (SUCCEEDED(hr) && IsEqualGUID(&container_format, &GUID_ContainerFormatPng))
|
|
{
|
|
/* disable PNG filters for faster encoding */
|
|
PROPBAG2 filter_option = { .pstrName = (LPOLESTR) L"FilterOption" };
|
|
VARIANT filter_value;
|
|
VariantInit(&filter_value);
|
|
V_VT(&filter_value) = VT_UI1;
|
|
V_UI1(&filter_value) = WICPngFilterNone;
|
|
hr = IPropertyBag2_Write(encoderoptions, 1, &filter_option, &filter_value);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = IWICBitmapFrameEncode_SetResolution(frameencode, image->xres, image->yres);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (i=0; pixel_formats[i].wic_format; i++)
|
|
{
|
|
if (pixel_formats[i].gdip_format == bitmap->format)
|
|
{
|
|
desired_wicformat = pixel_formats[i].wic_format;
|
|
gdipformat = bitmap->format;
|
|
break;
|
|
}
|
|
}
|
|
if (!gdipformat)
|
|
{
|
|
desired_wicformat = &GUID_WICPixelFormat32bppBGRA;
|
|
gdipformat = PixelFormat32bppARGB;
|
|
}
|
|
|
|
memcpy(&wicformat, desired_wicformat, sizeof(GUID));
|
|
hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && !IsEqualGUID(desired_wicformat, &wicformat))
|
|
{
|
|
/* Encoder doesn't support this bitmap's format. */
|
|
gdipformat = 0;
|
|
for (i=0; pixel_formats[i].wic_format; i++)
|
|
{
|
|
if (IsEqualGUID(&wicformat, pixel_formats[i].wic_format))
|
|
{
|
|
gdipformat = pixel_formats[i].gdip_format;
|
|
break;
|
|
}
|
|
}
|
|
if (!gdipformat)
|
|
{
|
|
ERR("Cannot support encoder format %s\n", debugstr_guid(&wicformat));
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && IsIndexedPixelFormat(gdipformat) && image->palette)
|
|
hr = set_palette(frameencode, image->palette);
|
|
|
|
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;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = IWICBitmapFrameEncode_Commit(frameencode);
|
|
|
|
IWICBitmapFrameEncode_Release(frameencode);
|
|
IPropertyBag2_Release(encoderoptions);
|
|
}
|
|
|
|
return hresult_to_status(hr);
|
|
}
|
|
|
|
static BOOL has_encoder_param_long(GDIPCONST EncoderParameters *params, GUID param_guid, ULONG val)
|
|
{
|
|
int param_idx, value_idx;
|
|
|
|
if (!params)
|
|
return FALSE;
|
|
|
|
for (param_idx = 0; param_idx < params->Count; param_idx++)
|
|
{
|
|
EncoderParameter param = params->Parameter[param_idx];
|
|
if (param.Type == EncoderParameterValueTypeLong && IsEqualCLSID(¶m.Guid, ¶m_guid))
|
|
{
|
|
ULONG *value_array = (ULONG*) param.Value;
|
|
for (value_idx = 0; value_idx < param.NumberOfValues; value_idx++)
|
|
{
|
|
if (value_array[value_idx] == val)
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static GpStatus encode_image_wic(GpImage *image, IStream *stream,
|
|
REFGUID container, GDIPCONST EncoderParameters *params)
|
|
{
|
|
GpStatus status, terminate_status;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
return GenericError;
|
|
|
|
status = initialize_encoder_wic(stream, container, image);
|
|
|
|
if (status == Ok)
|
|
status = encode_frame_wic(image->encoder, image);
|
|
|
|
if (!has_encoder_param_long(params, EncoderSaveFlag, EncoderValueMultiFrame))
|
|
{
|
|
/* always try to terminate, but if something already failed earlier, keep the old status. */
|
|
terminate_status = terminate_encoder_wic(image);
|
|
if (status == Ok)
|
|
status = terminate_status;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params)
|
|
{
|
|
return encode_image_wic(image, stream, &GUID_ContainerFormatBmp, params);
|
|
}
|
|
|
|
static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params)
|
|
{
|
|
return encode_image_wic(image, stream, &GUID_ContainerFormatTiff, params);
|
|
}
|
|
|
|
GpStatus encode_image_png(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params)
|
|
{
|
|
return encode_image_wic(image, stream, &GUID_ContainerFormatPng, params);
|
|
}
|
|
|
|
static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params)
|
|
{
|
|
return encode_image_wic(image, stream, &GUID_ContainerFormatJpeg, params);
|
|
}
|
|
|
|
static GpStatus encode_image_gif(GpImage *image, IStream* stream,
|
|
GDIPCONST EncoderParameters* params)
|
|
{
|
|
return encode_image_wic(image, stream, &GUID_ContainerFormatGif, params);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipSaveImageToStream [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
|
|
GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
|
|
{
|
|
GpStatus stat;
|
|
encode_image_func encode_image;
|
|
int i;
|
|
|
|
TRACE("%p, %p, %s, %p\n", image, stream, wine_dbgstr_guid(clsid), params);
|
|
|
|
if(!image || !stream)
|
|
return InvalidParameter;
|
|
|
|
/* select correct encoder */
|
|
encode_image = NULL;
|
|
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;
|
|
|
|
stat = encode_image(image, stream, params);
|
|
|
|
return stat;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipSaveAdd [GDIPLUS.@]
|
|
*
|
|
* Like GdipSaveAddImage(), but encode the currently active frame of the given image into the file
|
|
* or stream that is currently being encoded.
|
|
*/
|
|
GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
|
|
{
|
|
return GdipSaveAddImage(image, image, params);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipSaveAddImage [GDIPLUS.@]
|
|
*
|
|
* Encode the currently active frame of additional_image into the file or stream that is currently
|
|
* being encoded by the image given in the image parameter. The first frame of a multi-frame image
|
|
* must be encoded using the normal GdipSaveImageToStream() or GdipSaveImageToFile() functions,
|
|
* but with the "MultiFrame" encoding parameter set. The multi-frame encoding process must be
|
|
* finished after adding the last frame by calling GdipSaveAdd() with the "Flush" encoding parameter
|
|
* set.
|
|
*/
|
|
GpStatus WINGDIPAPI GdipSaveAddImage(GpImage *image, GpImage *additional_image,
|
|
GDIPCONST EncoderParameters *params)
|
|
{
|
|
TRACE("%p, %p, %p\n", image, additional_image, params);
|
|
|
|
if (!image || !additional_image || !params)
|
|
return InvalidParameter;
|
|
|
|
if (!image->encoder)
|
|
return Win32Error;
|
|
|
|
if (has_encoder_param_long(params, EncoderSaveFlag, EncoderValueFlush))
|
|
return terminate_encoder_wic(image);
|
|
else if (has_encoder_param_long(params, EncoderSaveFlag, EncoderValueFrameDimensionPage))
|
|
return encode_frame_wic(image->encoder, additional_image);
|
|
else
|
|
return InvalidParameter;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipGetImagePalette [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
|
|
{
|
|
INT count;
|
|
|
|
TRACE("(%p,%p,%i)\n", image, palette, size);
|
|
|
|
if (!image || !palette)
|
|
return InvalidParameter;
|
|
|
|
count = image->palette ? image->palette->Count : 0;
|
|
|
|
if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
|
|
{
|
|
TRACE("<-- InsufficientBuffer\n");
|
|
return InsufficientBuffer;
|
|
}
|
|
|
|
if (image->palette)
|
|
{
|
|
palette->Flags = image->palette->Flags;
|
|
palette->Count = image->palette->Count;
|
|
memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
|
|
}
|
|
else
|
|
{
|
|
palette->Flags = 0;
|
|
palette->Count = 0;
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipSetImagePalette [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
|
|
GDIPCONST ColorPalette *palette)
|
|
{
|
|
ColorPalette *new_palette;
|
|
|
|
TRACE("(%p,%p)\n", image, palette);
|
|
|
|
if(!image || !palette || palette->Count > 256)
|
|
return InvalidParameter;
|
|
|
|
new_palette = heap_alloc_zero(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
|
|
if (!new_palette) return OutOfMemory;
|
|
|
|
heap_free(image->palette);
|
|
image->palette = new_palette;
|
|
image->palette->Flags = palette->Flags;
|
|
image->palette->Count = palette->Count;
|
|
memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* Encoders -
|
|
* Structures that represent which formats we support for encoding.
|
|
*/
|
|
|
|
/* ImageCodecInfo creation routines taken from libgdiplus */
|
|
static const WCHAR bmp_codecname[] = L"Built-in BMP";
|
|
static const WCHAR bmp_extension[] = L"*.BMP;*.DIB;*.RLE";
|
|
static const WCHAR bmp_mimetype[] = L"image/bmp";
|
|
static const WCHAR bmp_format[] = L"BMP";
|
|
static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
|
|
static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
|
|
|
|
static const WCHAR jpeg_codecname[] = L"Built-in JPEG";
|
|
static const WCHAR jpeg_extension[] = L"*.JPG;*.JPEG;*.JPE;*.JFIF";
|
|
static const WCHAR jpeg_mimetype[] = L"image/jpeg";
|
|
static const WCHAR jpeg_format[] = L"JPEG";
|
|
static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
|
|
static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
|
|
|
|
static const WCHAR gif_codecname[] = L"Built-in GIF";
|
|
static const WCHAR gif_extension[] = L"*.GIF";
|
|
static const WCHAR gif_mimetype[] = L"image/gif";
|
|
static const WCHAR gif_format[] = L"GIF";
|
|
static const BYTE gif_sig_pattern[12] = "GIF87aGIF89a";
|
|
static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
|
|
|
|
static const WCHAR tiff_codecname[] = L"Built-in TIFF";
|
|
static const WCHAR tiff_extension[] = L"*.TIFF;*.TIF";
|
|
static const WCHAR tiff_mimetype[] = L"image/tiff";
|
|
static const WCHAR tiff_format[] = L"TIFF";
|
|
static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
|
|
static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
|
|
|
|
static const WCHAR emf_codecname[] = L"Built-in EMF";
|
|
static const WCHAR emf_extension[] = L"*.EMF";
|
|
static const WCHAR emf_mimetype[] = L"image/x-emf";
|
|
static const WCHAR emf_format[] = L"EMF";
|
|
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[] = L"Built-in WMF";
|
|
static const WCHAR wmf_extension[] = L"*.WMF";
|
|
static const WCHAR wmf_mimetype[] = L"image/x-wmf";
|
|
static const WCHAR wmf_format[] = L"WMF";
|
|
static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
|
|
static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
|
|
|
|
static const WCHAR png_codecname[] = L"Built-in PNG";
|
|
static const WCHAR png_extension[] = L"*.PNG";
|
|
static const WCHAR png_mimetype[] = L"image/png";
|
|
static const WCHAR png_format[] = L"PNG";
|
|
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[] = L"Built-in ICO";
|
|
static const WCHAR ico_extension[] = L"*.ICO";
|
|
static const WCHAR ico_mimetype[] = L"image/x-icon";
|
|
static const WCHAR ico_format[] = L"ICO";
|
|
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 } },
|
|
/* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
|
|
/* CodecName */ bmp_codecname,
|
|
/* DllName */ NULL,
|
|
/* FormatDescription */ bmp_format,
|
|
/* FilenameExtension */ bmp_extension,
|
|
/* MimeType */ bmp_mimetype,
|
|
/* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
|
|
/* Version */ 1,
|
|
/* SigCount */ 1,
|
|
/* SigSize */ 2,
|
|
/* SigPattern */ bmp_sig_pattern,
|
|
/* SigMask */ bmp_sig_mask,
|
|
},
|
|
encode_image_BMP,
|
|
decode_image_bmp,
|
|
select_frame_wic
|
|
},
|
|
{
|
|
{ /* 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 */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
|
|
/* Version */ 1,
|
|
/* SigCount */ 1,
|
|
/* SigSize */ 2,
|
|
/* SigPattern */ jpeg_sig_pattern,
|
|
/* SigMask */ jpeg_sig_mask,
|
|
},
|
|
encode_image_jpeg,
|
|
decode_image_jpeg,
|
|
select_frame_wic
|
|
},
|
|
{
|
|
{ /* 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 | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
|
|
/* Version */ 1,
|
|
/* SigCount */ 2,
|
|
/* SigSize */ 6,
|
|
/* SigPattern */ gif_sig_pattern,
|
|
/* SigMask */ gif_sig_mask,
|
|
},
|
|
encode_image_gif,
|
|
decode_image_gif,
|
|
select_frame_gif
|
|
},
|
|
{
|
|
{ /* TIFF */
|
|
/* Clsid */ { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
|
|
/* FormatID */ { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
|
|
/* CodecName */ tiff_codecname,
|
|
/* DllName */ NULL,
|
|
/* FormatDescription */ tiff_format,
|
|
/* FilenameExtension */ tiff_extension,
|
|
/* MimeType */ tiff_mimetype,
|
|
/* Flags */ ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
|
|
/* Version */ 1,
|
|
/* SigCount */ 2,
|
|
/* SigSize */ 4,
|
|
/* SigPattern */ tiff_sig_pattern,
|
|
/* SigMask */ tiff_sig_mask,
|
|
},
|
|
encode_image_tiff,
|
|
decode_image_tiff,
|
|
select_frame_wic
|
|
},
|
|
{
|
|
{ /* 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_emf,
|
|
NULL
|
|
},
|
|
{
|
|
{ /* 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_wmf,
|
|
NULL
|
|
},
|
|
{
|
|
{ /* 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,
|
|
select_frame_wic
|
|
},
|
|
{
|
|
{ /* 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,
|
|
select_frame_wic
|
|
},
|
|
};
|
|
|
|
/*****************************************************************************
|
|
* 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;
|
|
|
|
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;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipGetImageEncoders [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
|
|
{
|
|
int i, encoder_count=0;
|
|
TRACE("%u %u %p\n", numEncoders, size, encoders);
|
|
|
|
if (!encoders ||
|
|
size != numEncoders * sizeof(ImageCodecInfo))
|
|
return GenericError;
|
|
|
|
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;
|
|
}
|
|
|
|
GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
|
|
GDIPCONST CLSID* clsidEncoder, UINT *size)
|
|
{
|
|
static int calls;
|
|
|
|
TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
|
|
|
|
if(!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
*size = 0;
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
static PixelFormat get_16bpp_format(HBITMAP hbm)
|
|
{
|
|
BITMAPV4HEADER bmh;
|
|
HDC hdc;
|
|
PixelFormat result;
|
|
|
|
hdc = CreateCompatibleDC(NULL);
|
|
|
|
memset(&bmh, 0, sizeof(bmh));
|
|
bmh.bV4Size = sizeof(bmh);
|
|
bmh.bV4Width = 1;
|
|
bmh.bV4Height = 1;
|
|
bmh.bV4V4Compression = BI_BITFIELDS;
|
|
bmh.bV4BitCount = 16;
|
|
|
|
GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
|
|
|
|
if (bmh.bV4RedMask == 0x7c00 &&
|
|
bmh.bV4GreenMask == 0x3e0 &&
|
|
bmh.bV4BlueMask == 0x1f)
|
|
{
|
|
result = PixelFormat16bppRGB555;
|
|
}
|
|
else if (bmh.bV4RedMask == 0xf800 &&
|
|
bmh.bV4GreenMask == 0x7e0 &&
|
|
bmh.bV4BlueMask == 0x1f)
|
|
{
|
|
result = PixelFormat16bppRGB565;
|
|
}
|
|
else
|
|
{
|
|
FIXME("unrecognized bitfields %lx,%lx,%lx\n", bmh.bV4RedMask,
|
|
bmh.bV4GreenMask, bmh.bV4BlueMask);
|
|
result = PixelFormatUndefined;
|
|
}
|
|
|
|
DeleteDC(hdc);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
|
|
{
|
|
BITMAP bm;
|
|
GpStatus retval;
|
|
PixelFormat format;
|
|
BitmapData lockeddata;
|
|
char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
|
|
BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
|
|
|
|
TRACE("%p %p %p\n", hbm, hpal, bitmap);
|
|
|
|
if(!hbm || !bitmap)
|
|
return InvalidParameter;
|
|
|
|
if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
|
|
return InvalidParameter;
|
|
|
|
/* TODO: Figure out the correct format for 16, 32, 64 bpp */
|
|
switch(bm.bmBitsPixel) {
|
|
case 1:
|
|
format = PixelFormat1bppIndexed;
|
|
break;
|
|
case 4:
|
|
format = PixelFormat4bppIndexed;
|
|
break;
|
|
case 8:
|
|
format = PixelFormat8bppIndexed;
|
|
break;
|
|
case 16:
|
|
format = get_16bpp_format(hbm);
|
|
if (format == PixelFormatUndefined)
|
|
return InvalidParameter;
|
|
break;
|
|
case 24:
|
|
format = PixelFormat24bppRGB;
|
|
break;
|
|
case 32:
|
|
format = PixelFormat32bppRGB;
|
|
break;
|
|
case 48:
|
|
format = PixelFormat48bppRGB;
|
|
break;
|
|
default:
|
|
FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
|
|
format, NULL, bitmap);
|
|
|
|
if (retval == Ok)
|
|
{
|
|
retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
|
|
format, &lockeddata);
|
|
if (retval == Ok)
|
|
{
|
|
HDC hdc;
|
|
INT src_height;
|
|
|
|
hdc = CreateCompatibleDC(NULL);
|
|
|
|
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
pbmi->bmiHeader.biBitCount = 0;
|
|
|
|
GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
|
|
|
|
src_height = abs(pbmi->bmiHeader.biHeight);
|
|
pbmi->bmiHeader.biHeight = -src_height;
|
|
|
|
GetDIBits(hdc, hbm, 0, src_height, lockeddata.Scan0, pbmi, DIB_RGB_COLORS);
|
|
|
|
DeleteDC(hdc);
|
|
|
|
GdipBitmapUnlockBits(*bitmap, &lockeddata);
|
|
}
|
|
|
|
/* According to the tests hpal is ignored */
|
|
if (retval == Ok && pbmi->bmiHeader.biBitCount <= 8)
|
|
{
|
|
ColorPalette *palette;
|
|
int i, num_palette_entries;
|
|
|
|
num_palette_entries = pbmi->bmiHeader.biClrUsed;
|
|
if (!num_palette_entries)
|
|
num_palette_entries = 1 << pbmi->bmiHeader.biBitCount;
|
|
|
|
palette = heap_alloc_zero(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
|
|
if (!palette)
|
|
retval = OutOfMemory;
|
|
else
|
|
{
|
|
palette->Flags = 0;
|
|
palette->Count = num_palette_entries;
|
|
|
|
for (i=0; i<num_palette_entries; i++)
|
|
{
|
|
palette->Entries[i] = 0xff000000 | pbmi->bmiColors[i].rgbRed << 16 |
|
|
pbmi->bmiColors[i].rgbGreen << 8 | pbmi->bmiColors[i].rgbBlue;
|
|
}
|
|
|
|
retval = GdipSetImagePalette(&(*bitmap)->image, palette);
|
|
}
|
|
|
|
heap_free(palette);
|
|
}
|
|
|
|
if (retval != Ok)
|
|
{
|
|
GdipDisposeImage(&(*bitmap)->image);
|
|
*bitmap = NULL;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipCreateEffect [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipCreateEffect(const GUID guid, CGpEffect **effect)
|
|
{
|
|
FIXME("(%s, %p): stub\n", debugstr_guid(&guid), effect);
|
|
|
|
if(!effect)
|
|
return InvalidParameter;
|
|
|
|
*effect = NULL;
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipDeleteEffect [GDIPLUS.@]
|
|
*/
|
|
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 GdipSetEffectParameters(CGpEffect *effect,
|
|
const VOID *params, const UINT size)
|
|
{
|
|
static int calls;
|
|
|
|
TRACE("(%p,%p,%u)\n", effect, params, size);
|
|
|
|
if(!(calls++))
|
|
FIXME("not implemented\n");
|
|
|
|
return NotImplemented;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipGetImageFlags [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
|
|
{
|
|
TRACE("%p %p\n", image, flags);
|
|
|
|
if(!image || !flags)
|
|
return InvalidParameter;
|
|
|
|
*flags = image->flags;
|
|
|
|
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 GdipImageForceValidation(GpImage *image)
|
|
{
|
|
TRACE("%p\n", image);
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipGetImageThumbnail [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
|
|
GpImage **ret_image, GetThumbnailImageAbort cb,
|
|
VOID * cb_data)
|
|
{
|
|
GpStatus stat;
|
|
GpGraphics *graphics;
|
|
UINT srcwidth, srcheight;
|
|
|
|
TRACE("(%p %u %u %p %p %p)\n",
|
|
image, width, height, ret_image, cb, cb_data);
|
|
|
|
if (!image || !ret_image)
|
|
return InvalidParameter;
|
|
|
|
if (!width) width = 120;
|
|
if (!height) height = 120;
|
|
|
|
GdipGetImageWidth(image, &srcwidth);
|
|
GdipGetImageHeight(image, &srcheight);
|
|
|
|
stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
|
|
NULL, (GpBitmap**)ret_image);
|
|
|
|
if (stat == Ok)
|
|
{
|
|
stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
|
|
|
|
if (stat == Ok)
|
|
{
|
|
stat = GdipDrawImageRectRectI(graphics, image,
|
|
0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
|
|
NULL, NULL, NULL);
|
|
|
|
GdipDeleteGraphics(graphics);
|
|
}
|
|
|
|
if (stat != Ok)
|
|
{
|
|
GdipDisposeImage(*ret_image);
|
|
*ret_image = NULL;
|
|
}
|
|
}
|
|
|
|
return stat;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipImageRotateFlip [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
|
|
{
|
|
GpBitmap *new_bitmap;
|
|
GpBitmap *bitmap;
|
|
int bpp, bytesperpixel;
|
|
BOOL rotate_90, flip_x, flip_y;
|
|
int src_x_offset, src_y_offset;
|
|
LPBYTE src_origin;
|
|
UINT x, y, width, height;
|
|
BitmapData src_lock, dst_lock;
|
|
GpStatus stat;
|
|
BOOL unlock;
|
|
|
|
TRACE("(%p, %u)\n", image, type);
|
|
|
|
if (!image)
|
|
return InvalidParameter;
|
|
if (!image_lock(image, &unlock))
|
|
return ObjectBusy;
|
|
|
|
rotate_90 = type&1;
|
|
flip_x = (type&6) == 2 || (type&6) == 4;
|
|
flip_y = (type&3) == 1 || (type&3) == 2;
|
|
|
|
if (image->type != ImageTypeBitmap)
|
|
{
|
|
FIXME("Not implemented for type %i\n", image->type);
|
|
image_unlock(image, unlock);
|
|
return NotImplemented;
|
|
}
|
|
|
|
bitmap = (GpBitmap*)image;
|
|
bpp = PIXELFORMATBPP(bitmap->format);
|
|
|
|
if (bpp < 8)
|
|
{
|
|
FIXME("Not implemented for %i bit images\n", bpp);
|
|
image_unlock(image, unlock);
|
|
return NotImplemented;
|
|
}
|
|
|
|
if (rotate_90)
|
|
{
|
|
width = bitmap->height;
|
|
height = bitmap->width;
|
|
}
|
|
else
|
|
{
|
|
width = bitmap->width;
|
|
height = bitmap->height;
|
|
}
|
|
|
|
bytesperpixel = bpp/8;
|
|
|
|
stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
|
|
|
|
if (stat != Ok)
|
|
{
|
|
image_unlock(image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
|
|
|
|
if (stat == Ok)
|
|
{
|
|
stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
|
|
|
|
if (stat == Ok)
|
|
{
|
|
LPBYTE src_row, src_pixel;
|
|
LPBYTE dst_row, dst_pixel;
|
|
|
|
src_origin = src_lock.Scan0;
|
|
if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
|
|
if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
|
|
|
|
if (rotate_90)
|
|
{
|
|
if (flip_y) src_x_offset = -src_lock.Stride;
|
|
else src_x_offset = src_lock.Stride;
|
|
if (flip_x) src_y_offset = -bytesperpixel;
|
|
else src_y_offset = bytesperpixel;
|
|
}
|
|
else
|
|
{
|
|
if (flip_x) src_x_offset = -bytesperpixel;
|
|
else src_x_offset = bytesperpixel;
|
|
if (flip_y) src_y_offset = -src_lock.Stride;
|
|
else src_y_offset = src_lock.Stride;
|
|
}
|
|
|
|
src_row = src_origin;
|
|
dst_row = dst_lock.Scan0;
|
|
for (y=0; y<height; y++)
|
|
{
|
|
src_pixel = src_row;
|
|
dst_pixel = dst_row;
|
|
for (x=0; x<width; x++)
|
|
{
|
|
/* FIXME: This could probably be faster without memcpy. */
|
|
memcpy(dst_pixel, src_pixel, bytesperpixel);
|
|
dst_pixel += bytesperpixel;
|
|
src_pixel += src_x_offset;
|
|
}
|
|
src_row += src_y_offset;
|
|
dst_row += dst_lock.Stride;
|
|
}
|
|
|
|
GdipBitmapUnlockBits(new_bitmap, &dst_lock);
|
|
}
|
|
|
|
GdipBitmapUnlockBits(bitmap, &src_lock);
|
|
}
|
|
|
|
if (stat == Ok)
|
|
move_bitmap(bitmap, new_bitmap, FALSE);
|
|
else
|
|
GdipDisposeImage(&new_bitmap->image);
|
|
|
|
image_unlock(image, unlock);
|
|
return stat;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipImageSetAbort [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipImageSetAbort(GpImage *image, GdiplusAbort *pabort)
|
|
{
|
|
TRACE("(%p, %p)\n", image, pabort);
|
|
|
|
if (!image)
|
|
return InvalidParameter;
|
|
|
|
if (pabort)
|
|
FIXME("Abort callback is not supported.\n");
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipBitmapConvertFormat [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipBitmapConvertFormat(GpBitmap *bitmap, PixelFormat format, DitherType dithertype,
|
|
PaletteType palettetype, ColorPalette *palette, REAL alphathreshold)
|
|
{
|
|
FIXME("(%p, 0x%08x, %d, %d, %p, %f): stub\n", bitmap, format, dithertype, palettetype, palette, alphathreshold);
|
|
return NotImplemented;
|
|
}
|
|
|
|
static void set_histogram_point_argb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[ color >> 24 ]++;
|
|
ch1[(color >> 16) & 0xff]++;
|
|
ch2[(color >> 8) & 0xff]++;
|
|
ch3[ color & 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_pargb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
BYTE alpha = color >> 24;
|
|
|
|
ch0[alpha]++;
|
|
ch1[(((color >> 16) & 0xff) * alpha) / 0xff]++;
|
|
ch2[(((color >> 8) & 0xff) * alpha) / 0xff]++;
|
|
ch3[(( color & 0xff) * alpha) / 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_rgb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[(color >> 16) & 0xff]++;
|
|
ch1[(color >> 8) & 0xff]++;
|
|
ch2[ color & 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_gray(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[(76 * ((color >> 16) & 0xff) + 150 * ((color >> 8) & 0xff) + 29 * (color & 0xff)) / 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_b(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[color & 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_g(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[(color >> 8) & 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_r(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[(color >> 16) & 0xff]++;
|
|
}
|
|
|
|
static void set_histogram_point_a(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
ch0[(color >> 24) & 0xff]++;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipBitmapGetHistogram [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap *bitmap, HistogramFormat format, UINT num_of_entries,
|
|
UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
|
|
{
|
|
static void (* const set_histogram_point[])(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3) =
|
|
{
|
|
set_histogram_point_argb,
|
|
set_histogram_point_pargb,
|
|
set_histogram_point_rgb,
|
|
set_histogram_point_gray,
|
|
set_histogram_point_b,
|
|
set_histogram_point_g,
|
|
set_histogram_point_r,
|
|
set_histogram_point_a,
|
|
};
|
|
UINT width, height, x, y;
|
|
|
|
TRACE("(%p, %d, %u, %p, %p, %p, %p)\n", bitmap, format, num_of_entries,
|
|
ch0, ch1, ch2, ch3);
|
|
|
|
if (!bitmap || num_of_entries != 256)
|
|
return InvalidParameter;
|
|
|
|
/* Make sure passed channel pointers match requested format */
|
|
switch (format)
|
|
{
|
|
case HistogramFormatARGB:
|
|
case HistogramFormatPARGB:
|
|
if (!ch0 || !ch1 || !ch2 || !ch3)
|
|
return InvalidParameter;
|
|
memset(ch0, 0, num_of_entries * sizeof(UINT));
|
|
memset(ch1, 0, num_of_entries * sizeof(UINT));
|
|
memset(ch2, 0, num_of_entries * sizeof(UINT));
|
|
memset(ch3, 0, num_of_entries * sizeof(UINT));
|
|
break;
|
|
case HistogramFormatRGB:
|
|
if (!ch0 || !ch1 || !ch2 || ch3)
|
|
return InvalidParameter;
|
|
memset(ch0, 0, num_of_entries * sizeof(UINT));
|
|
memset(ch1, 0, num_of_entries * sizeof(UINT));
|
|
memset(ch2, 0, num_of_entries * sizeof(UINT));
|
|
break;
|
|
case HistogramFormatGray:
|
|
case HistogramFormatB:
|
|
case HistogramFormatG:
|
|
case HistogramFormatR:
|
|
case HistogramFormatA:
|
|
if (!ch0 || ch1 || ch2 || ch3)
|
|
return InvalidParameter;
|
|
memset(ch0, 0, num_of_entries * sizeof(UINT));
|
|
break;
|
|
default:
|
|
WARN("Invalid histogram format requested, %d\n", format);
|
|
return InvalidParameter;
|
|
}
|
|
|
|
GdipGetImageWidth(&bitmap->image, &width);
|
|
GdipGetImageHeight(&bitmap->image, &height);
|
|
|
|
for (y = 0; y < height; y++)
|
|
for (x = 0; x < width; x++)
|
|
{
|
|
ARGB color;
|
|
|
|
GdipBitmapGetPixel(bitmap, x, y, &color);
|
|
set_histogram_point[format](color, ch0, ch1, ch2, ch3);
|
|
}
|
|
|
|
return Ok;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipBitmapGetHistogramSize [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(HistogramFormat format, UINT *num_of_entries)
|
|
{
|
|
TRACE("(%d, %p)\n", format, num_of_entries);
|
|
|
|
if (!num_of_entries)
|
|
return InvalidParameter;
|
|
|
|
*num_of_entries = 256;
|
|
return Ok;
|
|
}
|
|
|
|
static GpStatus create_optimal_palette(ColorPalette *palette, INT desired,
|
|
BOOL transparent, GpBitmap *bitmap)
|
|
{
|
|
GpStatus status;
|
|
BitmapData data;
|
|
HRESULT hr;
|
|
IWICImagingFactory *factory;
|
|
IWICPalette *wic_palette;
|
|
|
|
if (!bitmap) return InvalidParameter;
|
|
if (palette->Count < desired) return GenericError;
|
|
|
|
status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, PixelFormat24bppRGB, &data);
|
|
if (status != Ok) return status;
|
|
|
|
hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
|
|
if (hr != S_OK)
|
|
{
|
|
GdipBitmapUnlockBits(bitmap, &data);
|
|
return hresult_to_status(hr);
|
|
}
|
|
|
|
hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
|
|
if (hr == S_OK)
|
|
{
|
|
IWICBitmap *bitmap;
|
|
|
|
/* PixelFormat24bppRGB actually stores the bitmap bits as BGR. */
|
|
hr = IWICImagingFactory_CreateBitmapFromMemory(factory, data.Width, data.Height,
|
|
&GUID_WICPixelFormat24bppBGR, data.Stride, data.Stride * data.Width, data.Scan0, &bitmap);
|
|
if (hr == S_OK)
|
|
{
|
|
hr = IWICPalette_InitializeFromBitmap(wic_palette, (IWICBitmapSource *)bitmap, desired, transparent);
|
|
if (hr == S_OK)
|
|
{
|
|
palette->Flags = 0;
|
|
IWICPalette_GetColorCount(wic_palette, &palette->Count);
|
|
IWICPalette_GetColors(wic_palette, palette->Count, (UINT *)palette->Entries, &palette->Count);
|
|
}
|
|
|
|
IWICBitmap_Release(bitmap);
|
|
}
|
|
|
|
IWICPalette_Release(wic_palette);
|
|
}
|
|
|
|
IWICImagingFactory_Release(factory);
|
|
GdipBitmapUnlockBits(bitmap, &data);
|
|
|
|
return hresult_to_status(hr);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* GdipInitializePalette [GDIPLUS.@]
|
|
*/
|
|
GpStatus WINGDIPAPI GdipInitializePalette(ColorPalette *palette,
|
|
PaletteType type, INT desired, BOOL transparent, GpBitmap *bitmap)
|
|
{
|
|
TRACE("(%p,%d,%d,%d,%p)\n", palette, type, desired, transparent, bitmap);
|
|
|
|
if (!palette) return InvalidParameter;
|
|
|
|
switch (type)
|
|
{
|
|
case PaletteTypeCustom:
|
|
return Ok;
|
|
|
|
case PaletteTypeOptimal:
|
|
return create_optimal_palette(palette, desired, transparent, bitmap);
|
|
|
|
/* WIC palette type enumeration matches these gdiplus enums */
|
|
case PaletteTypeFixedBW:
|
|
case PaletteTypeFixedHalftone8:
|
|
case PaletteTypeFixedHalftone27:
|
|
case PaletteTypeFixedHalftone64:
|
|
case PaletteTypeFixedHalftone125:
|
|
case PaletteTypeFixedHalftone216:
|
|
case PaletteTypeFixedHalftone252:
|
|
case PaletteTypeFixedHalftone256:
|
|
{
|
|
ColorPalette *wic_palette;
|
|
GpStatus status = Ok;
|
|
|
|
wic_palette = get_palette(NULL, type);
|
|
if (!wic_palette) return OutOfMemory;
|
|
|
|
if (palette->Count >= wic_palette->Count)
|
|
{
|
|
palette->Flags = wic_palette->Flags;
|
|
palette->Count = wic_palette->Count;
|
|
memcpy(palette->Entries, wic_palette->Entries, wic_palette->Count * sizeof(wic_palette->Entries[0]));
|
|
}
|
|
else
|
|
status = GenericError;
|
|
|
|
heap_free(wic_palette);
|
|
|
|
return status;
|
|
}
|
|
|
|
default:
|
|
FIXME("unknown palette type %d\n", type);
|
|
break;
|
|
}
|
|
|
|
return InvalidParameter;
|
|
}
|