static void test_create_decoder(void)
{
IWICBitmapDecoder *decoder;
IWICImagingFactory *factory;
HRESULT hr;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void **)&factory);
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICImagingFactory_CreateDecoder(factory, NULL, NULL, &decoder);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, NULL, &decoder);
ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
IWICBitmapDecoder_Release(decoder);
hr = IWICImagingFactory_CreateDecoder(factory, &GUID_ContainerFormatBmp, &GUID_VendorMicrosoft, &decoder);
ok(hr == S_OK, "CreateDecoder error %#x\n", hr);
IWICBitmapDecoder_Release(decoder);
IWICImagingFactory_Release(factory);
}
static HRESULT get_component_info(const GUID *clsid, IWICComponentInfo **result)
{
IWICImagingFactory *factory;
HRESULT hr;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return hr;
hr = IWICImagingFactory_CreateComponentInfo(factory, clsid, result);
IWICImagingFactory_Release(factory);
return hr;
}
static void test_createfromstream(void)
{
IWICBitmapDecoder *decoder;
IWICImagingFactory *factory;
HRESULT hr;
HGLOBAL hbmpdata;
char *bmpdata;
IStream *bmpstream;
GUID guidresult;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
ok(hbmpdata != 0, "GlobalAlloc failed\n");
if (hbmpdata)
{
bmpdata = GlobalLock(hbmpdata);
memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
GlobalUnlock(hbmpdata);
hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICImagingFactory_CreateDecoderFromStream(factory, bmpstream,
NULL, WICDecodeMetadataCacheOnDemand, &decoder);
ok(SUCCEEDED(hr), "CreateDecoderFromStream failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
IWICBitmapDecoder_Release(decoder);
}
IStream_Release(bmpstream);
}
GlobalFree(hbmpdata);
}
IWICImagingFactory_Release(factory);
}
static void test_reader_info(void)
{
IWICImagingFactory *factory;
IWICComponentInfo *info;
IWICMetadataReaderInfo *reader_info;
HRESULT hr;
CLSID clsid;
GUID container_formats[10];
UINT count, size;
WICMetadataPattern *patterns;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICUnknownMetadataReader, &info);
ok(hr == S_OK, "CreateComponentInfo failed, hr=%x\n", hr);
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICMetadataReaderInfo, (void**)&reader_info);
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, NULL);
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, &clsid);
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
ok(IsEqualGUID(&CLSID_WICUnknownMetadataReader, &clsid), "GetCLSID returned wrong result\n");
hr = IWICMetadataReaderInfo_GetMetadataFormat(reader_info, &clsid);
ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&GUID_MetadataFormatUnknown, &clsid), "GetMetadataFormat returned wrong result\n");
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, NULL);
ok(hr == E_INVALIDARG, "GetContainerFormats failed, hr=%x\n", hr);
count = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, &count);
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
ok(count == 0, "unexpected count %d\n", count);
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
0, NULL, NULL, NULL);
ok(hr == E_INVALIDARG, "GetPatterns failed, hr=%x\n", hr);
count = size = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
0, NULL, &count, &size);
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND || broken(hr == S_OK) /* Windows XP */,
"GetPatterns failed, hr=%x\n", hr);
ok(count == 0xdeadbeef, "unexpected count %d\n", count);
ok(size == 0xdeadbeef, "unexpected size %d\n", size);
IWICMetadataReaderInfo_Release(reader_info);
IWICComponentInfo_Release(info);
hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICXMPStructMetadataReader, &info);
todo_wine
ok(hr == S_OK, "CreateComponentInfo failed, hr=%x\n", hr);
if (FAILED(hr))
{
IWICImagingFactory_Release(factory);
return;
}
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICMetadataReaderInfo, (void**)&reader_info);
ok(hr == S_OK, "QueryInterface failed, hr=%x\n", hr);
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, NULL);
ok(hr == E_INVALIDARG, "GetCLSID failed, hr=%x\n", hr);
hr = IWICMetadataReaderInfo_GetCLSID(reader_info, &clsid);
ok(hr == S_OK, "GetCLSID failed, hr=%x\n", hr);
ok(IsEqualGUID(&CLSID_WICXMPStructMetadataReader, &clsid), "GetCLSID returned wrong result\n");
hr = IWICMetadataReaderInfo_GetMetadataFormat(reader_info, &clsid);
ok(hr == S_OK, "GetMetadataFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&GUID_MetadataFormatXMPStruct, &clsid), "GetMetadataFormat returned wrong result\n");
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, NULL);
ok(hr == E_INVALIDARG, "GetContainerFormats failed, hr=%x\n", hr);
count = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 0, NULL, &count);
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
ok(count >= 2, "unexpected count %d\n", count);
count = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 1, container_formats, &count);
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %d\n", count);
count = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetContainerFormats(reader_info, 10, container_formats, &count);
ok(hr == S_OK, "GetContainerFormats failed, hr=%x\n", hr);
ok(count == min(count, 10), "unexpected count %d\n", count);
count = size = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_ContainerFormatPng,
0, NULL, &count, &size);
ok(hr == WINCODEC_ERR_COMPONENTNOTFOUND || broken(hr == S_OK) /* Windows XP */,
"GetPatterns failed, hr=%x\n", hr);
ok(count == 0xdeadbeef, "unexpected count %d\n", count);
ok(size == 0xdeadbeef, "unexpected size %d\n", size);
count = size = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
0, NULL, &count, &size);
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %d\n", count);
ok(size > sizeof(WICMetadataPattern), "unexpected size %d\n", size);
if (hr == S_OK)
{
patterns = HeapAlloc(GetProcessHeap(), 0, size);
count = size = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
size-1, patterns, &count, &size);
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %d\n", count);
ok(size > sizeof(WICMetadataPattern), "unexpected size %d\n", size);
count = size = 0xdeadbeef;
hr = IWICMetadataReaderInfo_GetPatterns(reader_info, &GUID_MetadataFormatXMP,
size, patterns, &count, &size);
ok(hr == S_OK, "GetPatterns failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %d\n", count);
ok(size == sizeof(WICMetadataPattern) + patterns->Length * 2, "unexpected size %d\n", size);
HeapFree(GetProcessHeap(), 0, patterns);
}
IWICMetadataReaderInfo_Release(reader_info);
IWICComponentInfo_Release(info);
IWICImagingFactory_Release(factory);
}
HBITMAP LoadImageFromResources(
_In_ UINT Width,
_In_ UINT Height,
_In_ PCWSTR Name
)
{
UINT width = 0;
UINT height = 0;
UINT frameCount = 0;
BOOLEAN isSuccess = FALSE;
ULONG resourceLength = 0;
HGLOBAL resourceHandle = NULL;
HRSRC resourceHandleSource = NULL;
WICInProcPointer resourceBuffer = NULL;
BITMAPINFO bitmapInfo = { 0 };
HBITMAP bitmapHandle = NULL;
PBYTE bitmapBuffer = NULL;
IWICStream* wicStream = NULL;
IWICBitmapSource* wicBitmapSource = NULL;
IWICBitmapDecoder* wicDecoder = NULL;
IWICBitmapFrameDecode* wicFrame = NULL;
IWICImagingFactory* wicFactory = NULL;
IWICBitmapScaler* wicScaler = NULL;
WICPixelFormatGUID pixelFormat;
WICRect rect = { 0, 0, Width, Height };
__try
{
// Create the ImagingFactory
if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory1, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, &wicFactory)))
__leave;
// Find the resource
if ((resourceHandleSource = FindResource(PluginInstance->DllBase, Name, L"PNG")) == NULL)
__leave;
// Get the resource length
resourceLength = SizeofResource(PluginInstance->DllBase, resourceHandleSource);
// Load the resource
if ((resourceHandle = LoadResource(PluginInstance->DllBase, resourceHandleSource)) == NULL)
__leave;
if ((resourceBuffer = (WICInProcPointer)LockResource(resourceHandle)) == NULL)
__leave;
// Create the Stream
if (FAILED(IWICImagingFactory_CreateStream(wicFactory, &wicStream)))
__leave;
// Initialize the Stream from Memory
if (FAILED(IWICStream_InitializeFromMemory(wicStream, resourceBuffer, resourceLength)))
__leave;
if (FAILED(IWICImagingFactory_CreateDecoder(wicFactory, &GUID_ContainerFormatPng, NULL, &wicDecoder)))
__leave;
if (FAILED(IWICBitmapDecoder_Initialize(wicDecoder, (IStream*)wicStream, WICDecodeMetadataCacheOnLoad)))
__leave;
// Get the Frame count
if (FAILED(IWICBitmapDecoder_GetFrameCount(wicDecoder, &frameCount)) || frameCount < 1)
__leave;
// Get the Frame
if (FAILED(IWICBitmapDecoder_GetFrame(wicDecoder, 0, &wicFrame)))
__leave;
// Get the WicFrame image format
if (FAILED(IWICBitmapFrameDecode_GetPixelFormat(wicFrame, &pixelFormat)))
__leave;
// Check if the image format is supported:
if (IsEqualGUID(&pixelFormat, &GUID_WICPixelFormat32bppPBGRA)) // GUID_WICPixelFormat32bppRGB
{
wicBitmapSource = (IWICBitmapSource*)wicFrame;
}
else
{
// Convert the image to the correct format:
if (FAILED(WICConvertBitmapSource(&GUID_WICPixelFormat32bppPBGRA, (IWICBitmapSource*)wicFrame, &wicBitmapSource)))
__leave;
IWICBitmapFrameDecode_Release(wicFrame);
}
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = rect.Width;
bitmapInfo.bmiHeader.biHeight = -((LONG)rect.Height);
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
HDC hdc = CreateCompatibleDC(NULL);
bitmapHandle = CreateDIBSection(hdc, &bitmapInfo, DIB_RGB_COLORS, (PVOID*)&bitmapBuffer, NULL, 0);
ReleaseDC(NULL, hdc);
// Check if it's the same rect as the requested size.
//if (width != rect.Width || height != rect.Height)
if (FAILED(IWICImagingFactory_CreateBitmapScaler(wicFactory, &wicScaler)))
__leave;
if (FAILED(IWICBitmapScaler_Initialize(wicScaler, wicBitmapSource, rect.Width, rect.Height, WICBitmapInterpolationModeFant)))
__leave;
if (FAILED(IWICBitmapScaler_CopyPixels(wicScaler, &rect, rect.Width * 4, rect.Width * rect.Height * 4, bitmapBuffer)))
__leave;
isSuccess = TRUE;
}
__finally
{
if (wicScaler)
{
IWICBitmapScaler_Release(wicScaler);
}
if (wicBitmapSource)
{
IWICBitmapSource_Release(wicBitmapSource);
}
if (wicStream)
{
IWICStream_Release(wicStream);
}
if (wicDecoder)
{
IWICBitmapDecoder_Release(wicDecoder);
}
if (wicFactory)
{
IWICImagingFactory_Release(wicFactory);
}
if (resourceHandle)
{
FreeResource(resourceHandle);
}
}
return bitmapHandle;
}
static void test_componentinfo(void)
{
IWICImagingFactory *factory;
IWICComponentInfo *info;
IWICBitmapDecoderInfo *decoderinfo;
IWICBitmapDecoder *decoder;
HRESULT hr;
WICBitmapPattern *patterns;
UINT pattern_count, pattern_size;
WICComponentType type;
GUID guidresult;
HGLOBAL hbmpdata;
char *bmpdata;
IStream *bmpstream;
BOOL boolresult;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICBmpDecoder, &info);
ok(SUCCEEDED(hr), "CreateComponentInfo failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICComponentInfo_GetComponentType(info, &type);
ok(SUCCEEDED(hr), "GetComponentType failed, hr=%x\n", hr);
ok(type == WICDecoder, "got %i, expected WICDecoder\n", type);
hr = IWICComponentInfo_QueryInterface(info, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
ok(SUCCEEDED(hr), "QueryInterface failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
pattern_count = 0;
pattern_size = 0;
hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, 0, NULL, &pattern_count, &pattern_size);
ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
ok(pattern_count != 0, "pattern count is 0\n");
ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
patterns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pattern_size);
hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
ok(pattern_count != 0, "pattern count is 0\n");
ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
ok(patterns[0].Length != 0, "pattern length is 0\n");
ok(patterns[0].Pattern != NULL, "pattern is NULL\n");
ok(patterns[0].Mask != NULL, "mask is NULL\n");
pattern_size -= 1;
hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetPatterns returned %x, expected WINCODEC_ERR_INSUFFICIENTBUFFER\n", hr);
HeapFree(GetProcessHeap(), 0, patterns);
hr = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
ok(SUCCEEDED(hr), "CreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
IWICBitmapDecoder_Release(decoder);
}
hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
ok(hbmpdata != 0, "GlobalAlloc failed\n");
if (hbmpdata)
{
bmpdata = GlobalLock(hbmpdata);
memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
GlobalUnlock(hbmpdata);
hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
boolresult = 0;
hr = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, bmpstream, &boolresult);
ok(SUCCEEDED(hr), "MatchesPattern failed, hr=%x\n", hr);
ok(boolresult, "pattern not matched\n");
IStream_Release(bmpstream);
}
GlobalFree(hbmpdata);
}
IWICBitmapDecoderInfo_Release(decoderinfo);
}
IWICComponentInfo_Release(info);
}
IWICImagingFactory_Release(factory);
}
}
static void test_decode_rle4(void)
{
IWICBitmapDecoder *decoder, *decoder2;
IWICBitmapFrameDecode *framedecode;
HRESULT hr;
HGLOBAL hbmpdata;
char *bmpdata;
IStream *bmpstream;
DWORD capability=0;
GUID guidresult;
UINT count=0, width=0, height=0;
double dpiX, dpiY;
DWORD imagedata[64] = {1};
const DWORD expected_imagedata[64] = {
0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000,
0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000};
WICColor palettedata[6] = {1};
const WICColor expected_palettedata[6] = {
0xff000000,0xff0000ff,0xffff0000,0xffff00ff,0xff00ff00,0xffffffff};
WICRect rc;
hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICBitmapDecoder, (void**)&decoder);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
ok(hbmpdata != 0, "GlobalAlloc failed\n");
if (hbmpdata)
{
bmpdata = GlobalLock(hbmpdata);
memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
GlobalUnlock(hbmpdata);
hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %u\n", count);
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
IWICImagingFactory *factory;
IWICPalette *palette;
hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
ok(width == 8, "expected width=8, got %u\n", width);
ok(height == 8, "expected height=8, got %u\n", height);
hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 6, "expected count=6, got %u\n", count);
hr = IWICPalette_GetColors(palette, 6, palettedata, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 6, "expected count=6, got %u\n", count);
ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
rc.X = 0;
rc.Y = 0;
rc.Width = 8;
rc.Height = 8;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
IWICBitmapFrameDecode_Release(framedecode);
}
hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICBitmapDecoder, (void**)&decoder2);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
"unexpected capabilities: %x\n", capability);
IWICBitmapDecoder_Release(decoder2);
}
IStream_Release(bmpstream);
}
GlobalFree(hbmpdata);
}
IWICBitmapDecoder_Release(decoder);
}
static void test_decode_24bpp(void)
{
IWICBitmapDecoder *decoder, *decoder2;
IWICBitmapFrameDecode *framedecode;
IWICMetadataQueryReader *queryreader;
IWICColorContext *colorcontext;
IWICBitmapSource *thumbnail;
HRESULT hr;
HGLOBAL hbmpdata;
char *bmpdata;
IStream *bmpstream;
DWORD capability=0;
GUID guidresult;
UINT count=0, width=0, height=0;
double dpiX, dpiY;
BYTE imagedata[36] = {1};
const BYTE expected_imagedata[36] = {
255,0,255, 255,255,255,
255,0,0, 255,255,0,
0,0,0, 0,255,0};
WICRect rc;
hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICBitmapDecoder, (void**)&decoder);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_24bpp));
ok(hbmpdata != 0, "GlobalAlloc failed\n");
if (hbmpdata)
{
bmpdata = GlobalLock(hbmpdata);
memcpy(bmpdata, testbmp_24bpp, sizeof(testbmp_24bpp));
GlobalUnlock(hbmpdata);
hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
ok(hr == S_OK || broken(hr == WINCODEC_ERR_BADIMAGE) /* XP */, "Initialize failed, hr=%x\n", hr);
if (FAILED(hr))
{
win_skip("BMP decoder failed to initialize\n");
GlobalFree(hbmpdata);
IWICBitmapDecoder_Release(decoder);
return;
}
hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
hr = IWICBitmapDecoder_GetMetadataQueryReader(decoder, &queryreader);
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
hr = IWICBitmapDecoder_GetColorContexts(decoder, 1, &colorcontext, &count);
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
hr = IWICBitmapDecoder_GetThumbnail(decoder, &thumbnail);
ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
hr = IWICBitmapDecoder_GetPreview(decoder, &thumbnail);
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
ok(count == 1, "unexpected count %u\n", count);
hr = IWICBitmapDecoder_GetFrame(decoder, 1, &framedecode);
ok(hr == E_INVALIDARG || hr == WINCODEC_ERR_FRAMEMISSING, "GetFrame returned %x\n", hr);
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
IWICImagingFactory *factory;
IWICPalette *palette;
hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
ok(width == 2, "expected width=2, got %u\n", width);
ok(height == 3, "expected height=2, got %u\n", height);
hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
hr = IWICBitmapFrameDecode_GetMetadataQueryReader(framedecode, &queryreader);
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
hr = IWICBitmapFrameDecode_GetColorContexts(framedecode, 1, &colorcontext, &count);
ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
hr = IWICBitmapFrameDecode_GetThumbnail(framedecode, &thumbnail);
ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
rc.X = 0;
rc.Y = 0;
rc.Width = 3;
rc.Height = 3;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
rc.X = -1;
rc.Y = 0;
rc.Width = 2;
rc.Height = 3;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
rc.X = 0;
rc.Y = 0;
rc.Width = 2;
rc.Height = 3;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, sizeof(imagedata), imagedata);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
rc.X = 0;
rc.Y = 0;
rc.Width = 2;
rc.Height = 3;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, 5, imagedata);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
rc.X = 0;
rc.Y = 0;
rc.Width = 2;
rc.Height = 3;
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
hr = IWICBitmapFrameDecode_CopyPixels(framedecode, NULL, 6, sizeof(imagedata), imagedata);
ok(SUCCEEDED(hr), "CopyPixels(rect=NULL) failed, hr=%x\n", hr);
ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
IWICBitmapFrameDecode_Release(framedecode);
}
/* cannot initialize twice */
hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
/* cannot querycapability after initialize */
hr = IWICBitmapDecoder_QueryCapability(decoder, bmpstream, &capability);
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICBitmapDecoder, (void**)&decoder2);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
"unexpected capabilities: %x\n", capability);
/* cannot initialize after querycapability */
hr = IWICBitmapDecoder_Initialize(decoder2, bmpstream, WICDecodeMetadataCacheOnLoad);
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
/* cannot querycapability twice */
hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
IWICBitmapDecoder_Release(decoder2);
}
IStream_Release(bmpstream);
}
GlobalFree(hbmpdata);
}
IWICBitmapDecoder_Release(decoder);
}
static void test_gif_notrailer(void)
{
IWICBitmapDecoder *decoder;
IWICImagingFactory *factory;
HRESULT hr;
IWICStream *gifstream;
IWICBitmapFrameDecode *framedecode;
double dpiX = 0.0, dpiY = 0.0;
UINT framecount;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hr = IWICImagingFactory_CreateStream(factory, &gifstream);
ok(hr == S_OK, "CreateStream failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICStream_InitializeFromMemory(gifstream, gifimage_notrailer,
sizeof(gifimage_notrailer));
ok(hr == S_OK, "InitializeFromMemory failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(&CLSID_WICGifDecoder, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICBitmapDecoder, (void**)&decoder);
ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
}
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)gifstream,
WICDecodeMetadataCacheOnDemand);
ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
ok(hr == S_OK, "GetFrame failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
ok(dpiX == 48.0, "expected dpiX=48.0, got %f\n", dpiX);
ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
IWICBitmapFrameDecode_Release(framedecode);
}
}
if (SUCCEEDED(hr))
{
hr = IWICBitmapDecoder_GetFrameCount(decoder, &framecount);
ok(hr == S_OK, "GetFrameCount failed, hr=%x\n", hr);
ok(framecount == 1, "framecount=%u\n", framecount);
}
IWICBitmapDecoder_Release(decoder);
}
IWICStream_Release(gifstream);
}
IWICImagingFactory_Release(factory);
}
static void test_StreamOnStreamRange(void)
{
IWICImagingFactory *pFactory;
IWICStream *pStream, *pSubStream;
IStream *CopyStream;
const BYTE CmpMem[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
};
BYTE Memory[64], MemBuf[64];
LARGE_INTEGER LargeNull, LargeInt;
ULARGE_INTEGER uLargeNull, uNewPos, uSize;
ULONG uBytesRead, uBytesWritten;
HRESULT hr;
STATSTG Stats;
LargeNull.QuadPart = 0;
uLargeNull.QuadPart = 0;
memcpy(Memory, CmpMem, sizeof(CmpMem));
CoInitialize(NULL);
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, (void**)&pFactory);
if(FAILED(hr)) {
skip("CoCreateInstance returned with %#x, expected %#x\n", hr, S_OK);
return;
}
hr = IWICImagingFactory_CreateStream(pFactory, &pStream);
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
if(FAILED(hr)) {
skip("Failed to create stream\n");
return;
}
hr = IWICStream_InitializeFromMemory(pStream, Memory, sizeof(Memory));
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
hr = IWICImagingFactory_CreateStream(pFactory, &pSubStream);
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
uNewPos.QuadPart = 20;
uSize.QuadPart = 20;
hr = IWICStream_InitializeFromIStreamRegion(pSubStream, (IStream*)pStream, uNewPos, uSize);
ok(hr == S_OK, "InitializeFromIStreamRegion returned with %#x, expected %#x\n", hr, S_OK);
if(FAILED(hr)) {
skip("InitializeFromIStreamRegion unimplemented\n");
IWICStream_Release(pSubStream);
IWICStream_Release(pStream);
IWICImagingFactory_Release(pFactory);
CoUninitialize();
return;
}
/* Seek */
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_END, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 20, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 20);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
LargeInt.u.HighPart = 1;
LargeInt.u.LowPart = 0;
uNewPos.u.HighPart = 0xdeadbeef;
uNewPos.u.LowPart = 0xdeadbeef;
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
LargeInt.QuadPart = 30;
uNewPos.u.HighPart = 0xdeadbeef;
uNewPos.u.LowPart = 0xdeadbeef;
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_SET, &uNewPos);
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
LargeInt.QuadPart = 1;
uNewPos.u.HighPart = 0xdeadbeef;
uNewPos.u.LowPart = 0xdeadbeef;
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE, "Seek returned with %#x, expected %#x\n", hr, WINCODEC_ERR_VALUEOUTOFRANGE);
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
LargeInt.QuadPart = -1;
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 19, "bSeek cursor moved to position (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, &uNewPos); /* reset seek pointer */
LargeInt.QuadPart = -25;
uNewPos.u.HighPart = 0xdeadbeef;
uNewPos.u.LowPart = 0xdeadbeef;
hr = IWICStream_Seek(pSubStream, LargeInt, STREAM_SEEK_END, &uNewPos);
ok(hr == WINCODEC_ERR_VALUEOUTOFRANGE,
"Seek returned with %#x, expected %#x\n", hr, HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW));
ok(uNewPos.u.HighPart == 0xdeadbeef && uNewPos.u.LowPart == 0xdeadbeef, "Seek cursor initialized to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0xdeadbeef, 0xdeadbeef);
hr = IWICStream_Seek(pStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0); /* remains unchanged */
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
/* Read */
hr = IWICStream_Read(pSubStream, MemBuf, 12, &uBytesRead);
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesRead == 12, "Read %u bytes, expected %u\n", uBytesRead, 12);
ok(memcmp(MemBuf, CmpMem+20, 12) == 0, "Read returned invalid data!\n");
/* check whether the seek pointer has moved correctly */
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesRead, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesRead);
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
hr = IWICStream_Read(pSubStream, Memory, 10, &uBytesRead); /* source = dest */
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesRead == 10, "Read %u bytes, expected %u\n", uBytesRead, 10);
ok(memcmp(Memory, CmpMem+20, uBytesRead) == 0, "Read returned invalid data!\n");
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
hr = IWICStream_Read(pSubStream, Memory, 30, &uBytesRead); /* request too many bytes */
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesRead == 20, "Read %u bytes\n", uBytesRead);
ok(memcmp(Memory, CmpMem+20, uBytesRead) == 0, "Read returned invalid data!\n");
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
uBytesRead = 0xdeadbeef;
hr = IWICStream_Read(pSubStream, NULL, 1, &uBytesRead); /* destination buffer = NULL */
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
ok(uBytesRead == 0xdeadbeef, "Expected uBytesRead to be unchanged, got %u\n", uBytesRead);
hr = IWICStream_Read(pSubStream, MemBuf, 0, &uBytesRead); /* read 0 bytes */
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
uBytesRead = 0xdeadbeef;
hr = IWICStream_Read(pSubStream, NULL, 0, &uBytesRead);
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
ok(uBytesRead == 0xdeadbeef, "Expected uBytesRead to be unchanged, got %u\n", uBytesRead);
hr = IWICStream_Read(pSubStream, NULL, 0, NULL);
ok(hr == E_INVALIDARG, "Read returned with %#x, expected %#x\n", hr, E_INVALIDARG);
hr = IWICStream_Read(pSubStream, MemBuf, 1, NULL);
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
ZeroMemory(MemBuf, sizeof(MemBuf));
hr = IWICStream_Read(pSubStream, MemBuf, 30, &uBytesRead);
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesRead == 20, "Read %u bytes\n", uBytesRead);
ok(memcmp(Memory, CmpMem+20, 20) == 0, "Read returned invalid data!\n");
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
/* Write */
MemBuf[0] = CmpMem[0] + 1;
MemBuf[1] = CmpMem[1] + 1;
MemBuf[2] = CmpMem[2] + 1;
hr = IWICStream_Write(pSubStream, MemBuf, 3, &uBytesWritten);
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesWritten == 3, "Wrote %u bytes, expected %u\n", uBytesWritten, 3);
ok(memcmp(MemBuf, Memory+20, 3) == 0, "Wrote returned invalid data!\n"); /* make sure we're writing directly */
/* check whether the seek pointer has moved correctly */
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesWritten, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesWritten);
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
hr = IWICStream_Write(pSubStream, MemBuf, 0, &uBytesWritten);
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
uBytesWritten = 0xdeadbeef;
hr = IWICStream_Write(pSubStream, NULL, 3, &uBytesWritten);
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
uBytesWritten = 0xdeadbeef;
hr = IWICStream_Write(pSubStream, NULL, 0, &uBytesWritten);
ok(hr == E_INVALIDARG, "Write returned with %#x, expected %#x\n", hr, E_INVALIDARG);
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
hr = IWICStream_Write(pSubStream, CmpMem, 30, &uBytesWritten);
ok(hr == S_OK, "Write returned with %#x, expected %#x\n", hr, STG_E_MEDIUMFULL);
ok(uBytesWritten == 20, "Wrote %u bytes, expected %u\n", uBytesWritten, 0);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == uBytesWritten, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, uBytesWritten);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
/* SetSize */
uNewPos.u.HighPart = 0;
uNewPos.u.LowPart = sizeof(Memory) + 10;
hr = IWICStream_SetSize(pSubStream, uNewPos);
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
uNewPos.u.HighPart = 0;
uNewPos.u.LowPart = sizeof(Memory);
hr = IWICStream_SetSize(pSubStream, uNewPos);
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
uNewPos.u.HighPart = 0;
uNewPos.u.LowPart = sizeof(Memory) - 10;
hr = IWICStream_SetSize(pSubStream, uNewPos);
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
uNewPos.u.HighPart = 0;
uNewPos.u.LowPart = 0;
hr = IWICStream_SetSize(pSubStream, uNewPos);
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
uNewPos.QuadPart = -10;
hr = IWICStream_SetSize(pSubStream, uNewPos);
ok(hr == E_NOTIMPL, "SetSize returned %#x, expected %#x\n", hr, E_NOTIMPL);
/* CopyTo */
uNewPos.u.HighPart = 0;
uNewPos.u.LowPart = 30;
hr = IWICStream_CopyTo(pSubStream, NULL, uNewPos, NULL, NULL);
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = CreateStreamOnHGlobal(NULL, TRUE, &CopyStream);
ok(hr == S_OK, "CreateStream failed with %#x\n", hr);
hr = IWICStream_CopyTo(pSubStream, CopyStream, uNewPos, NULL, NULL);
ok(hr == E_NOTIMPL, "CopyTo returned %#x, expected %#x\n", hr, E_NOTIMPL);
IStream_Release(CopyStream);
/* Commit */
hr = IWICStream_Commit(pSubStream, STGC_DEFAULT);
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = IWICStream_Commit(pSubStream, STGC_OVERWRITE);
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = IWICStream_Commit(pSubStream, STGC_ONLYIFCURRENT);
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = IWICStream_Commit(pSubStream, STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = IWICStream_Commit(pSubStream, STGC_CONSOLIDATE);
ok(hr == E_NOTIMPL, "Commit returned %#x, expected %#x\n", hr, E_NOTIMPL);
/* Revert */
IWICStream_Write(pSubStream, &MemBuf[5], 6, NULL);
hr = IWICStream_Revert(pSubStream);
ok(hr == E_NOTIMPL, "Revert returned %#x, expected %#x\n", hr, E_NOTIMPL);
memcpy(Memory, CmpMem, sizeof(Memory));
/* LockRegion/UnlockRegion */
hr = IWICStream_LockRegion(pSubStream, uLargeNull, uLargeNull, 0);
ok(hr == E_NOTIMPL, "LockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
hr = IWICStream_UnlockRegion(pSubStream, uLargeNull, uLargeNull, 0);
ok(hr == E_NOTIMPL, "UnlockRegion returned %#x, expected %#x\n", hr, E_NOTIMPL);
/* Stat */
hr = IWICStream_Stat(pSubStream, NULL, 0);
ok(hr == E_INVALIDARG, "Stat returned %#x, expected %#x\n", hr, E_INVALIDARG);
hr = IWICStream_Stat(pSubStream, &Stats, 0);
ok(hr == S_OK, "Stat returned %#x, expected %#x\n", hr, S_OK);
ok(Stats.pwcsName == NULL, "Stat returned name %p, expected %p\n", Stats.pwcsName, NULL);
ok(Stats.type == STGTY_STREAM, "Stat returned type %d, expected %d\n", Stats.type, STGTY_STREAM);
ok(Stats.cbSize.u.HighPart == 0 && Stats.cbSize.u.LowPart == 20, "Stat returned size (%u;%u)\n", Stats.cbSize.u.HighPart, Stats.cbSize.u.LowPart);
ok(Stats.mtime.dwHighDateTime == 0 && Stats.mtime.dwLowDateTime == 0, "Stat returned mtime (%u;%u), expected (%u;%u)\n", Stats.mtime.dwHighDateTime, Stats.mtime.dwLowDateTime, 0, 0);
ok(Stats.ctime.dwHighDateTime == 0 && Stats.ctime.dwLowDateTime == 0, "Stat returned ctime (%u;%u), expected (%u;%u)\n", Stats.ctime.dwHighDateTime, Stats.ctime.dwLowDateTime, 0, 0);
ok(Stats.atime.dwHighDateTime == 0 && Stats.atime.dwLowDateTime == 0, "Stat returned atime (%u;%u), expected (%u;%u)\n", Stats.atime.dwHighDateTime, Stats.atime.dwLowDateTime, 0, 0);
ok(Stats.grfMode == 0, "Stat returned access mode %d, expected %d\n", Stats.grfMode, 0);
ok(Stats.grfLocksSupported == 0, "Stat returned supported locks %#x, expected %#x\n", Stats.grfLocksSupported, 0);
ok(Stats.grfStateBits == 0, "Stat returned state bits %#x, expected %#x\n", Stats.grfStateBits, 0);
/* Clone */
hr = IWICStream_Clone(pSubStream, &CopyStream);
ok(hr == E_NOTIMPL, "Clone returned %#x, expected %#x\n", hr, E_NOTIMPL);
IWICStream_Release(pSubStream);
/* Recreate, this time larger than the original. */
hr = IWICImagingFactory_CreateStream(pFactory, &pSubStream);
ok(hr == S_OK, "CreateStream returned with %#x, expected %#x\n", hr, S_OK);
uNewPos.QuadPart = 48;
uSize.QuadPart = 32;
hr = IWICStream_InitializeFromIStreamRegion(pSubStream, (IStream*)pStream, uNewPos, uSize);
ok(hr == S_OK, "InitializeFromMemory returned with %#x, expected %#x\n", hr, S_OK);
hr = IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_END, &uNewPos);
ok(hr == S_OK, "Seek returned with %#x, expected %#x\n", hr, S_OK);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 16, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 16);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
hr = IWICStream_Read(pSubStream, Memory, 48, &uBytesRead);
ok(hr == S_OK, "Read returned with %#x, expected %#x\n", hr, S_OK);
if(SUCCEEDED(hr)) {
ok(uBytesRead == 16, "Read %u bytes\n", uBytesRead);
ok(memcmp(Memory, CmpMem+48, uBytesRead) == 0, "Read returned invalid data!\n");
}
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_SET, NULL);
uBytesWritten = 0xdeadbeef;
hr = IWICStream_Write(pSubStream, CmpMem, 32, &uBytesWritten);
ok(hr == STG_E_MEDIUMFULL, "Write returned with %#x, expected %#x\n", hr, STG_E_MEDIUMFULL);
ok(uBytesWritten == 0xdeadbeef, "Expected uBytesWritten to be unchanged, got %u\n", uBytesWritten);
IWICStream_Seek(pSubStream, LargeNull, STREAM_SEEK_CUR, &uNewPos);
ok(uNewPos.u.HighPart == 0 && uNewPos.u.LowPart == 0, "Seek cursor moved to position (%u;%u), expected (%u;%u)\n", uNewPos.u.HighPart, uNewPos.u.LowPart, 0, 0);
IWICStream_Release(pSubStream);
IWICStream_Release(pStream);
IWICImagingFactory_Release(pFactory);
CoUninitialize();
}
static void test_predefined_palette(void)
{
static struct test_data
{
WICBitmapPaletteType type;
BOOL is_bw, is_gray;
UINT count;
WICColor color[256];
BOOL add_transparent;
} td[] =
{
{ WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff } },
{ WICBitmapPaletteTypeFixedBW, 1, 1, 2, { 0xff000000, 0xffffffff }, 1 },
{ WICBitmapPaletteTypeFixedGray4, 0, 1, 4,
{ 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff } },
{ WICBitmapPaletteTypeFixedGray4, 0, 1, 4,
{ 0xff000000, 0xff555555, 0xffaaaaaa, 0xffffffff }, 1 },
{ WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 } },
{ WICBitmapPaletteTypeFixedGray16, 0, 1, 16, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 } },
{ WICBitmapPaletteTypeFixedGray256, 0, 1, 256, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone8, 0, 0, 16, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone8, 0, 0, 17, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone27, 0, 0, 28, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone27, 0, 0, 29, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone64, 0, 0, 72, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone64, 0, 0, 73, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone125, 0, 0, 126, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone125, 0, 0, 127, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone216, 0, 0, 224, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone216, 0, 0, 225, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone252, 0, 0, 252, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone252, 0, 0, 253, { 0 }, 1 },
{ WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 } },
{ WICBitmapPaletteTypeFixedHalftone256, 0, 0, 256, { 0 }, 1 }
};
IWICImagingFactory *factory;
IWICPalette *palette;
HRESULT hr;
WICBitmapPaletteType type;
UINT count, i, ret;
BOOL bret;
WICColor color[256];
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void **)&factory);
ok(hr == S_OK, "CoCreateInstance error %#x\n", hr);
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(hr == S_OK, "CreatePalette error %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeCustom, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeMedianCut, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
hr = IWICPalette_InitializePredefined(palette, 0x0f, FALSE);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %#x\n", hr);
IWICPalette_Release(palette);
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
{
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(hr == S_OK, "%u: CreatePalette error %#x\n", i, hr);
hr = IWICPalette_InitializePredefined(palette, td[i].type, td[i].add_transparent);
ok(hr == S_OK, "%u: InitializePredefined error %#x\n", i, hr);
bret = -1;
hr = IWICPalette_IsBlackWhite(palette, &bret);
ok(hr == S_OK, "%u: IsBlackWhite error %#x\n", i, hr);
ok(bret == td[i].is_bw ||
broken(td[i].type == WICBitmapPaletteTypeFixedBW && bret != td[i].is_bw), /* XP */
"%u: expected %d, got %d\n",i, td[i].is_bw, bret);
bret = -1;
hr = IWICPalette_IsGrayscale(palette, &bret);
ok(hr == S_OK, "%u: IsGrayscale error %#x\n", i, hr);
ok(bret == td[i].is_gray, "%u: expected %d, got %d\n", i, td[i].is_gray, bret);
type = -1;
hr = IWICPalette_GetType(palette, &type);
ok(hr == S_OK, "%u: GetType error %#x\n", i, hr);
ok(type == td[i].type, "%u: expected %#x, got %#x\n", i, td[i].type, type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette, &count);
ok(hr == S_OK, "%u: GetColorCount error %#x\n", i, hr);
ok(count == td[i].count, "%u: expected %u, got %u\n", i, td[i].count, count);
hr = IWICPalette_GetColors(palette, count, color, &ret);
ok(hr == S_OK, "%u: GetColors error %#x\n", i, hr);
ok(ret == count, "%u: expected %u, got %u\n", i, count, ret);
if (ret == td[i].count)
{
UINT j;
if (td[i].type == WICBitmapPaletteTypeFixedGray16)
generate_gray16_palette(td[i].color, td[i].count);
else if (td[i].type == WICBitmapPaletteTypeFixedGray256)
generate_gray256_palette(td[i].color, td[i].count);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone8)
generate_halftone8_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone27)
generate_halftone27_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone64)
generate_halftone64_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone125)
generate_halftone125_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone216)
generate_halftone216_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone252)
generate_halftone252_palette(td[i].color, td[i].count, td[i].add_transparent);
else if (td[i].type == WICBitmapPaletteTypeFixedHalftone256)
generate_halftone256_palette(td[i].color, td[i].count, td[i].add_transparent);
for (j = 0; j < count; j++)
{
ok(color[j] == td[i].color[j], "%u:[%u]: expected %#x, got %#x\n",
i, j, td[i].color[j], color[j]);
}
}
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
static void test_custom_palette(void)
{
IWICImagingFactory *factory;
IWICPalette *palette, *palette2;
HRESULT hr;
WICBitmapPaletteType type=0xffffffff;
UINT count=1;
const WICColor initcolors[4]={0xff000000,0xff0000ff,0xffffff00,0xffffffff};
WICColor colors[4];
BOOL boolresult;
hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
&IID_IWICImagingFactory, (void**)&factory);
ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
if (FAILED(hr)) return;
hr = IWICImagingFactory_CreatePalette(factory, &palette);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
if (SUCCEEDED(hr))
{
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_GetColors(palette, 0, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
memcpy(colors, initcolors, sizeof(initcolors));
hr = IWICPalette_InitializeCustom(palette, colors, 4);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0;
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
memset(colors, 0, sizeof(colors));
count = 0;
hr = IWICPalette_GetColors(palette, 2, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 2, "expected 2, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(WICColor)*2), "got unexpected palette data\n");
count = 0;
hr = IWICPalette_GetColors(palette, 6, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
hr = IWICPalette_HasAlpha(palette, &boolresult);
ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICPalette_IsBlackWhite(palette, &boolresult);
ok(SUCCEEDED(hr), "IsBlackWhite failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICPalette_IsGrayscale(palette, &boolresult);
ok(SUCCEEDED(hr), "IsGrayscale failed, hr=%x\n", hr);
ok(!boolresult, "expected FALSE, got TRUE\n");
hr = IWICImagingFactory_CreatePalette(factory, &palette2);
ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
hr = IWICPalette_InitializeFromPalette(palette2, palette);
ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette2, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette2, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette2, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 4, "expected 4, got %u\n", count);
ok(!memcmp(colors, initcolors, sizeof(colors)), "got unexpected palette data\n");
/* try a palette with some alpha in it */
colors[2] = 0x80ffffff;
hr = IWICPalette_InitializeCustom(palette, colors, 4);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
hr = IWICPalette_HasAlpha(palette, &boolresult);
ok(SUCCEEDED(hr), "HasAlpha failed, hr=%x\n", hr);
ok(boolresult, "expected TRUE, got FALSE\n");
/* setting to a 0-color palette is acceptable */
hr = IWICPalette_InitializeCustom(palette, NULL, 0);
ok(SUCCEEDED(hr), "InitializeCustom failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
hr = IWICPalette_InitializeFromPalette(palette2, palette);
ok(SUCCEEDED(hr), "InitializeFromPalette failed, hr=%x\n", hr);
type = 0xdeadbeef;
hr = IWICPalette_GetType(palette2, &type);
ok(SUCCEEDED(hr), "GetType failed, hr=%x\n", hr);
ok(type == WICBitmapPaletteTypeCustom, "expected WICBitmapPaletteTypeCustom, got %x\n", type);
count = 0xdeadbeef;
hr = IWICPalette_GetColorCount(palette2, &count);
ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
memset(colors, 0, sizeof(colors));
count = 0xdeadbeef;
hr = IWICPalette_GetColors(palette2, 4, colors, &count);
ok(SUCCEEDED(hr), "GetColors failed, hr=%x\n", hr);
ok(count == 0, "expected 0, got %u\n", count);
/* IWICPalette is paranoid about NULL pointers */
hr = IWICPalette_GetType(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColorCount(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_InitializeCustom(palette, NULL, 4);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColors(palette, 4, NULL, &count);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_GetColors(palette, 4, colors, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_HasAlpha(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_IsBlackWhite(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_IsGrayscale(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
hr = IWICPalette_InitializeFromPalette(palette, NULL);
ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
IWICPalette_Release(palette2);
IWICPalette_Release(palette);
}
IWICImagingFactory_Release(factory);
}
HBITMAP LoadPngImageFromResources(
_In_ PCWSTR Name
)
{
BOOLEAN success = FALSE;
UINT frameCount = 0;
ULONG resourceLength = 0;
HGLOBAL resourceHandle = NULL;
HRSRC resourceHandleSource = NULL;
WICInProcPointer resourceBuffer = NULL;
HDC screenHdc = NULL;
HDC bufferDc = NULL;
BITMAPINFO bitmapInfo = { 0 };
HBITMAP bitmapHandle = NULL;
PVOID bitmapBuffer = NULL;
IWICStream* wicStream = NULL;
IWICBitmapSource* wicBitmapSource = NULL;
IWICBitmapDecoder* wicDecoder = NULL;
IWICBitmapFrameDecode* wicFrame = NULL;
IWICImagingFactory* wicFactory = NULL;
IWICBitmapScaler* wicScaler = NULL;
WICPixelFormatGUID pixelFormat;
WICRect rect = { 0, 0, 164, 164 };
// Create the ImagingFactory
if (FAILED(CoCreateInstance(&CLSID_WICImagingFactory1, NULL, CLSCTX_INPROC_SERVER, &IID_IWICImagingFactory, &wicFactory)))
goto CleanupExit;
// Find the resource
if ((resourceHandleSource = FindResource(PhInstanceHandle, Name, L"PNG")) == NULL)
goto CleanupExit;
// Get the resource length
resourceLength = SizeofResource(PhInstanceHandle, resourceHandleSource);
// Load the resource
if ((resourceHandle = LoadResource(PhInstanceHandle, resourceHandleSource)) == NULL)
goto CleanupExit;
if ((resourceBuffer = (WICInProcPointer)LockResource(resourceHandle)) == NULL)
goto CleanupExit;
// Create the Stream
if (FAILED(IWICImagingFactory_CreateStream(wicFactory, &wicStream)))
goto CleanupExit;
// Initialize the Stream from Memory
if (FAILED(IWICStream_InitializeFromMemory(wicStream, resourceBuffer, resourceLength)))
goto CleanupExit;
if (FAILED(IWICImagingFactory_CreateDecoder(wicFactory, &GUID_ContainerFormatPng, NULL, &wicDecoder)))
goto CleanupExit;
if (FAILED(IWICBitmapDecoder_Initialize(wicDecoder, (IStream*)wicStream, WICDecodeMetadataCacheOnLoad)))
goto CleanupExit;
// Get the Frame count
if (FAILED(IWICBitmapDecoder_GetFrameCount(wicDecoder, &frameCount)) || frameCount < 1)
goto CleanupExit;
// Get the Frame
if (FAILED(IWICBitmapDecoder_GetFrame(wicDecoder, 0, &wicFrame)))
goto CleanupExit;
// Get the WicFrame image format
if (FAILED(IWICBitmapFrameDecode_GetPixelFormat(wicFrame, &pixelFormat)))
goto CleanupExit;
// Check if the image format is supported:
if (IsEqualGUID(&pixelFormat, &GUID_WICPixelFormat32bppPRGBA))
{
wicBitmapSource = (IWICBitmapSource*)wicFrame;
}
else
{
IWICFormatConverter* wicFormatConverter = NULL;
if (FAILED(IWICImagingFactory_CreateFormatConverter(wicFactory, &wicFormatConverter)))
goto CleanupExit;
if (FAILED(IWICFormatConverter_Initialize(
wicFormatConverter,
(IWICBitmapSource*)wicFrame,
&GUID_WICPixelFormat32bppPRGBA,
WICBitmapDitherTypeNone,
NULL,
0.0,
WICBitmapPaletteTypeCustom
)))
{
IWICFormatConverter_Release(wicFormatConverter);
goto CleanupExit;
}
// Convert the image to the correct format:
IWICFormatConverter_QueryInterface(wicFormatConverter, &IID_IWICBitmapSource, &wicBitmapSource);
// Cleanup the converter.
IWICFormatConverter_Release(wicFormatConverter);
// Dispose the old frame now that the converted frame is in wicBitmapSource.
IWICBitmapFrameDecode_Release(wicFrame);
}
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = rect.Width;
bitmapInfo.bmiHeader.biHeight = -((LONG)rect.Height);
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
screenHdc = CreateIC(L"DISPLAY", NULL, NULL, NULL);
bufferDc = CreateCompatibleDC(screenHdc);
bitmapHandle = CreateDIBSection(screenHdc, &bitmapInfo, DIB_RGB_COLORS, &bitmapBuffer, NULL, 0);
// Check if it's the same rect as the requested size.
//if (width != rect.Width || height != rect.Height)
if (FAILED(IWICImagingFactory_CreateBitmapScaler(wicFactory, &wicScaler)))
goto CleanupExit;
if (FAILED(IWICBitmapScaler_Initialize(wicScaler, wicBitmapSource, rect.Width, rect.Height, WICBitmapInterpolationModeFant)))
goto CleanupExit;
if (FAILED(IWICBitmapScaler_CopyPixels(wicScaler, &rect, rect.Width * 4, rect.Width * rect.Height * 4, (PBYTE)bitmapBuffer)))
goto CleanupExit;
success = TRUE;
CleanupExit:
if (wicScaler)
IWICBitmapScaler_Release(wicScaler);
if (bufferDc)
DeleteDC(bufferDc);
if (screenHdc)
DeleteDC(screenHdc);
if (wicBitmapSource)
IWICBitmapSource_Release(wicBitmapSource);
if (wicStream)
IWICStream_Release(wicStream);
if (wicDecoder)
IWICBitmapDecoder_Release(wicDecoder);
if (wicFactory)
IWICImagingFactory_Release(wicFactory);
if (resourceHandle)
FreeResource(resourceHandle);
if (success)
{
return bitmapHandle;
}
DeleteObject(bitmapHandle);
return NULL;
}
