static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface, UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE *buffer, IWICBitmap **bitmap) { HRESULT hr; TRACE("(%p,%u,%u,%s,%u,%u,%p,%p\n", iface, width, height, debugstr_guid(format), stride, size, buffer, bitmap); if (!stride || !size || !buffer || !bitmap) return E_INVALIDARG; hr = BitmapImpl_Create(width, height, stride, size, NULL, 0, format, WICBitmapCacheOnLoad, bitmap); if (SUCCEEDED(hr)) { IWICBitmapLock *lock; hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock); if (SUCCEEDED(hr)) { UINT buffersize; BYTE *data; IWICBitmapLock_GetDataPointer(lock, &buffersize, &data); memcpy(data, buffer, buffersize); IWICBitmapLock_Release(lock); } else { IWICBitmap_Release(*bitmap); *bitmap = NULL; } } return hr; }
static HRESULT d2d_wic_render_target_present(IUnknown *outer_unknown) { struct d2d_wic_render_target *render_target = impl_from_IUnknown(outer_unknown); D3D10_MAPPED_TEXTURE2D mapped_texture; ID3D10Resource *src_resource; IWICBitmapLock *bitmap_lock; UINT dst_size, dst_pitch; ID3D10Device *device; WICRect dst_rect; BYTE *src, *dst; unsigned int i; HRESULT hr; if (FAILED(hr = IDXGISurface_QueryInterface(render_target->dxgi_surface, &IID_ID3D10Resource, (void **)&src_resource))) { ERR("Failed to get source resource interface, hr %#x.\n", hr); goto end; } ID3D10Texture2D_GetDevice(render_target->readback_texture, &device); ID3D10Device_CopyResource(device, (ID3D10Resource *)render_target->readback_texture, src_resource); ID3D10Device_Release(device); ID3D10Resource_Release(src_resource); dst_rect.X = 0; dst_rect.Y = 0; dst_rect.Width = render_target->width; dst_rect.Height = render_target->height; if (FAILED(hr = IWICBitmap_Lock(render_target->bitmap, &dst_rect, WICBitmapLockWrite, &bitmap_lock))) { ERR("Failed to lock destination bitmap, hr %#x.\n", hr); goto end; } if (FAILED(hr = IWICBitmapLock_GetDataPointer(bitmap_lock, &dst_size, &dst))) { ERR("Failed to get data pointer, hr %#x.\n", hr); IWICBitmapLock_Release(bitmap_lock); goto end; } if (FAILED(hr = IWICBitmapLock_GetStride(bitmap_lock, &dst_pitch))) { ERR("Failed to get stride, hr %#x.\n", hr); IWICBitmapLock_Release(bitmap_lock); goto end; } if (FAILED(hr = ID3D10Texture2D_Map(render_target->readback_texture, 0, D3D10_MAP_READ, 0, &mapped_texture))) { ERR("Failed to map readback texture, hr %#x.\n", hr); IWICBitmapLock_Release(bitmap_lock); goto end; } src = mapped_texture.pData; for (i = 0; i < render_target->height; ++i) { memcpy(dst, src, render_target->bpp * render_target->width); src += mapped_texture.RowPitch; dst += dst_pitch; } ID3D10Texture2D_Unmap(render_target->readback_texture, 0); IWICBitmapLock_Release(bitmap_lock); end: return S_OK; }
static void test_createbitmapfromsource(void) { HRESULT hr; IWICBitmap *bitmap, *bitmap2; IWICPalette *palette; IWICBitmapLock *lock; int i; WICRect rc; const BYTE bitmap_data[27] = { 128,128,255, 128,128,128, 128,255,128, 128,128,128, 128,128,128, 255,255,255, 255,128,128, 255,255,255, 255,255,255}; BYTE returned_data[27] = {0}; BYTE *lock_buffer=NULL; UINT lock_buffer_stride=0; UINT lock_buffer_size=0; WICPixelFormatGUID pixelformat = {0}; UINT width=0, height=0; double dpix=10.0, dpiy=10.0; UINT count; WICBitmapPaletteType palette_type; hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR, WICBitmapCacheOnLoad, &bitmap); ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr); if (FAILED(hr)) return; hr = IWICImagingFactory_CreatePalette(factory, &palette); ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr); hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE); ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr); hr = IWICBitmap_SetPalette(bitmap, palette); ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr); IWICPalette_Release(palette); rc.X = rc.Y = 0; rc.Width = 3; rc.Height = 3; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock); ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) { hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride); ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr); ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride); hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer); ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr); ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size); ok(lock_buffer != NULL, "got NULL data pointer\n"); for (i=0; i<3; i++) memcpy(lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9); IWICBitmapLock_Release(lock); } hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0); ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr); hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap, WICBitmapCacheOnLoad, &bitmap2); ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr); IWICBitmap_Release(bitmap); if (FAILED(hr)) return; hr = IWICImagingFactory_CreatePalette(factory, &palette); ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr); /* palette isn't copied for non-indexed formats? */ hr = IWICBitmap_CopyPalette(bitmap2, palette); ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr); IWICPalette_Release(palette); hr = IWICBitmap_CopyPixels(bitmap2, NULL, 9, 27, returned_data); ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr); for (i=0; i<27; i++) ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]); hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat); ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n"); hr = IWICBitmap_GetResolution(bitmap2, &dpix, &dpiy); ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr); ok(dpix == 12.0, "got %f, expected 12.0\n", dpix); ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy); hr = IWICBitmap_GetSize(bitmap2, &width, &height); ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr); ok(width == 3, "got %d, expected 3\n", width); ok(height == 3, "got %d, expected 3\n", height); IWICBitmap_Release(bitmap2); /* Ensure palette is copied for indexed formats */ hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat4bppIndexed, WICBitmapCacheOnLoad, &bitmap); ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr); hr = IWICImagingFactory_CreatePalette(factory, &palette); ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr); hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE); ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr); hr = IWICBitmap_SetPalette(bitmap, palette); ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr); IWICPalette_Release(palette); hr = IWICImagingFactory_CreateBitmapFromSource(factory, (IWICBitmapSource*)bitmap, WICBitmapCacheOnLoad, &bitmap2); ok(hr == S_OK, "IWICImagingFactory_CreateBitmapFromSource failed hr=%x\n", hr); IWICBitmap_Release(bitmap); hr = IWICImagingFactory_CreatePalette(factory, &palette); ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr); hr = IWICBitmap_CopyPalette(bitmap2, palette); ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr); hr = IWICPalette_GetColorCount(palette, &count); ok(hr == S_OK, "IWICPalette_GetColorCount failed hr=%x\n", hr); ok(count == 256, "unexpected count %d\n", count); hr = IWICPalette_GetType(palette, &palette_type); ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr); ok(palette_type == WICBitmapPaletteTypeFixedGray256, "unexpected palette type %d\n", palette_type); IWICPalette_Release(palette); hr = IWICBitmap_GetPixelFormat(bitmap2, &pixelformat); ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n"); hr = IWICBitmap_GetSize(bitmap2, &width, &height); ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr); ok(width == 3, "got %d, expected 3\n", width); ok(height == 3, "got %d, expected 3\n", height); IWICBitmap_Release(bitmap2); }
static void test_createbitmap(void) { HRESULT hr; IWICBitmap *bitmap; IWICPalette *palette; IWICBitmapLock *lock, *lock2; WICBitmapPaletteType palettetype; int i; WICRect rc; const BYTE bitmap_data[27] = { 128,128,255, 128,128,128, 128,255,128, 128,128,128, 128,128,128, 255,255,255, 255,128,128, 255,255,255, 255,255,255}; BYTE returned_data[27] = {0}; BYTE *lock_buffer=NULL, *base_lock_buffer=NULL; UINT lock_buffer_size=0; UINT lock_buffer_stride=0; WICPixelFormatGUID pixelformat = {0}; UINT width=0, height=0; double dpix=10.0, dpiy=10.0; int can_lock_null = 1; hr = IWICImagingFactory_CreateBitmap(factory, 3, 3, &GUID_WICPixelFormat24bppBGR, WICBitmapCacheOnLoad, &bitmap); ok(hr == S_OK, "IWICImagingFactory_CreateBitmap failed hr=%x\n", hr); if (FAILED(hr)) return; hr = IWICImagingFactory_CreatePalette(factory, &palette); ok(hr == S_OK, "IWICImagingFactory_CreatePalette failed hr=%x\n", hr); /* Palette is unavailable until explicitly set */ hr = IWICBitmap_CopyPalette(bitmap, palette); ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "IWICBitmap_CopyPalette failed hr=%x\n", hr); hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray256, FALSE); ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr); hr = IWICBitmap_SetPalette(bitmap, palette); ok(hr == S_OK, "IWICBitmap_SetPalette failed hr=%x\n", hr); hr = IWICPalette_InitializePredefined(palette, WICBitmapPaletteTypeFixedGray4, FALSE); ok(hr == S_OK, "IWICPalette_InitializePredefined failed hr=%x\n", hr); hr = IWICBitmap_CopyPalette(bitmap, palette); ok(hr == S_OK, "IWICBitmap_CopyPalette failed hr=%x\n", hr); hr = IWICPalette_GetType(palette, &palettetype); ok(hr == S_OK, "IWICPalette_GetType failed hr=%x\n", hr); ok(palettetype == WICBitmapPaletteTypeFixedGray256, "expected WICBitmapPaletteTypeFixedGray256, got %x\n", palettetype); IWICPalette_Release(palette); /* pixel data is initially zeroed */ hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data); ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr); for (i=0; i<27; i++) ok(returned_data[i] == 0, "returned_data[%i] == %i\n", i, returned_data[i]); /* Invalid lock rects */ rc.X = rc.Y = 0; rc.Width = 4; rc.Height = 3; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock); ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock); rc.Width = 3; rc.Height = 4; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock); ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock); rc.Height = 3; rc.X = 4; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock); ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock); rc.X = 0; rc.Y = 4; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock); ok(hr == E_INVALIDARG, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) IWICBitmapLock_Release(lock); /* NULL lock rect */ hr = IWICBitmap_Lock(bitmap, NULL, WICBitmapLockRead, &lock); ok(hr == S_OK || broken(hr == E_INVALIDARG) /* winxp */, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) { /* entire bitmap is locked */ hr = IWICBitmapLock_GetSize(lock, &width, &height); ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr); ok(width == 3, "got %d, expected 3\n", width); ok(height == 3, "got %d, expected 3\n", height); IWICBitmapLock_Release(lock); } else can_lock_null = 0; /* lock with a valid rect */ rc.Y = 0; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock); ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) { hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride); ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr); /* stride is divisible by 4 */ ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride); hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer); ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr); /* buffer size does not include padding from the last row */ ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size); ok(lock_buffer != NULL, "got NULL data pointer\n"); base_lock_buffer = lock_buffer; hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat); ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n"); hr = IWICBitmapLock_GetSize(lock, &width, &height); ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr); ok(width == 3, "got %d, expected 3\n", width); ok(height == 3, "got %d, expected 3\n", height); /* We can have multiple simultaneous read locks */ hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2); ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) { hr = IWICBitmapLock_GetDataPointer(lock2, &lock_buffer_size, &lock_buffer); ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr); ok(lock_buffer_size == 33, "got %i, expected 33\n", lock_buffer_size); ok(lock_buffer == base_lock_buffer, "got %p, expected %p\n", lock_buffer, base_lock_buffer); IWICBitmapLock_Release(lock2); } if (can_lock_null) /* this hangs on xp/vista */ { /* But not a read and a write lock */ hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2); ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr); } /* But we don't need a write lock to write */ if (base_lock_buffer) { for (i=0; i<3; i++) memcpy(base_lock_buffer + lock_buffer_stride*i, bitmap_data + i*9, 9); } IWICBitmapLock_Release(lock); } /* test that the data we wrote is returned by CopyPixels */ hr = IWICBitmap_CopyPixels(bitmap, NULL, 9, 27, returned_data); ok(hr == S_OK, "IWICBitmap_CopyPixels failed hr=%x\n", hr); for (i=0; i<27; i++) ok(returned_data[i] == bitmap_data[i], "returned_data[%i] == %i\n", i, returned_data[i]); /* try a valid partial rect, and write mode */ rc.X = 2; rc.Y = 0; rc.Width = 1; rc.Height = 2; hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock); ok(hr == S_OK, "IWICBitmap_Lock failed hr=%x\n", hr); if (SUCCEEDED(hr)) { if (can_lock_null) /* this hangs on xp/vista */ { /* Can't lock again while locked for writing */ hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockWrite, &lock2); ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr); hr = IWICBitmap_Lock(bitmap, &rc, WICBitmapLockRead, &lock2); ok(hr == WINCODEC_ERR_ALREADYLOCKED, "IWICBitmap_Lock failed hr=%x\n", hr); } hr = IWICBitmapLock_GetStride(lock, &lock_buffer_stride); ok(hr == S_OK, "IWICBitmapLock_GetStride failed hr=%x\n", hr); ok(lock_buffer_stride == 12, "got %i, expected 12\n", lock_buffer_stride); hr = IWICBitmapLock_GetDataPointer(lock, &lock_buffer_size, &lock_buffer); ok(hr == S_OK, "IWICBitmapLock_GetDataPointer failed hr=%x\n", hr); ok(lock_buffer_size == 15, "got %i, expected 15\n", lock_buffer_size); ok(lock_buffer == base_lock_buffer+6, "got %p, expected %p+6\n", lock_buffer, base_lock_buffer); hr = IWICBitmapLock_GetPixelFormat(lock, &pixelformat); ok(hr == S_OK, "IWICBitmapLock_GetPixelFormat failed hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n"); hr = IWICBitmapLock_GetSize(lock, &width, &height); ok(hr == S_OK, "IWICBitmapLock_GetSize failed hr=%x\n", hr); ok(width == 1, "got %d, expected 1\n", width); ok(height == 2, "got %d, expected 2\n", height); IWICBitmapLock_Release(lock); } hr = IWICBitmap_GetPixelFormat(bitmap, &pixelformat); ok(hr == S_OK, "IWICBitmap_GetPixelFormat failed hr=%x\n", hr); ok(IsEqualGUID(&pixelformat, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n"); hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy); ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr); ok(dpix == 0.0, "got %f, expected 0.0\n", dpix); ok(dpiy == 0.0, "got %f, expected 0.0\n", dpiy); hr = IWICBitmap_SetResolution(bitmap, 12.0, 34.0); ok(hr == S_OK, "IWICBitmap_SetResolution failed hr=%x\n", hr); hr = IWICBitmap_GetResolution(bitmap, &dpix, &dpiy); ok(hr == S_OK, "IWICBitmap_GetResolution failed hr=%x\n", hr); ok(dpix == 12.0, "got %f, expected 12.0\n", dpix); ok(dpiy == 34.0, "got %f, expected 34.0\n", dpiy); hr = IWICBitmap_GetSize(bitmap, &width, &height); ok(hr == S_OK, "IWICBitmap_GetSize failed hr=%x\n", hr); ok(width == 3, "got %d, expected 3\n", width); ok(height == 3, "got %d, expected 3\n", height); IWICBitmap_Release(bitmap); }
static HRESULT WINAPI ComponentFactory_CreateBitmapFromSource(IWICComponentFactory *iface, IWICBitmapSource *piBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) { IWICBitmap *result; IWICBitmapLock *lock; IWICPalette *palette; UINT width, height; WICPixelFormatGUID pixelformat = {0}; HRESULT hr; WICRect rc; double dpix, dpiy; IWICComponentInfo *info; IWICPixelFormatInfo2 *formatinfo; WICPixelFormatNumericRepresentation format_type; TRACE("(%p,%p,%u,%p)\n", iface, piBitmapSource, option, ppIBitmap); if (!piBitmapSource || !ppIBitmap) return E_INVALIDARG; hr = IWICBitmapSource_GetSize(piBitmapSource, &width, &height); if (SUCCEEDED(hr)) hr = IWICBitmapSource_GetPixelFormat(piBitmapSource, &pixelformat); if (SUCCEEDED(hr)) hr = CreateComponentInfo(&pixelformat, &info); if (SUCCEEDED(hr)) { hr = IWICComponentInfo_QueryInterface(info, &IID_IWICPixelFormatInfo2, (void**)&formatinfo); if (SUCCEEDED(hr)) { hr = IWICPixelFormatInfo2_GetNumericRepresentation(formatinfo, &format_type); IWICPixelFormatInfo2_Release(formatinfo); } IWICComponentInfo_Release(info); } if (SUCCEEDED(hr)) hr = BitmapImpl_Create(width, height, &pixelformat, option, &result); if (SUCCEEDED(hr)) { hr = IWICBitmap_Lock(result, NULL, WICBitmapLockWrite, &lock); if (SUCCEEDED(hr)) { UINT stride, buffersize; BYTE *buffer; rc.X = rc.Y = 0; rc.Width = width; rc.Height = height; hr = IWICBitmapLock_GetStride(lock, &stride); if (SUCCEEDED(hr)) hr = IWICBitmapLock_GetDataPointer(lock, &buffersize, &buffer); if (SUCCEEDED(hr)) hr = IWICBitmapSource_CopyPixels(piBitmapSource, &rc, stride, buffersize, buffer); IWICBitmapLock_Release(lock); } if (SUCCEEDED(hr)) hr = PaletteImpl_Create(&palette); if (SUCCEEDED(hr) && (format_type == WICPixelFormatNumericRepresentationUnspecified || format_type == WICPixelFormatNumericRepresentationIndexed)) { hr = IWICBitmapSource_CopyPalette(piBitmapSource, palette); if (SUCCEEDED(hr)) hr = IWICBitmap_SetPalette(result, palette); else hr = S_OK; IWICPalette_Release(palette); } if (SUCCEEDED(hr)) { hr = IWICBitmapSource_GetResolution(piBitmapSource, &dpix, &dpiy); if (SUCCEEDED(hr)) hr = IWICBitmap_SetResolution(result, dpix, dpiy); else hr = S_OK; } if (SUCCEEDED(hr)) *ppIBitmap = result; else IWICBitmap_Release(result); } return hr; }
static HRESULT WINAPI ComponentFactory_CreateBitmapFromHICON(IWICComponentFactory *iface, HICON hicon, IWICBitmap **bitmap) { IWICBitmapLock *lock; ICONINFO info; BITMAP bm; int width, height, x, y; UINT stride, size; BYTE *buffer; DWORD *bits; BITMAPINFO bi; HDC hdc; BOOL has_alpha; HRESULT hr; TRACE("(%p,%p,%p)\n", iface, hicon, bitmap); if (!bitmap) return E_INVALIDARG; if (!GetIconInfo(hicon, &info)) return HRESULT_FROM_WIN32(GetLastError()); GetObjectW(info.hbmColor ? info.hbmColor : info.hbmMask, sizeof(bm), &bm); width = bm.bmWidth; height = info.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2; stride = width * 4; size = stride * height; hr = BitmapImpl_Create(width, height, stride, size, NULL, &GUID_WICPixelFormat32bppBGRA, WICBitmapCacheOnLoad, bitmap); if (hr != S_OK) goto failed; hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock); if (hr != S_OK) { IWICBitmap_Release(*bitmap); goto failed; } IWICBitmapLock_GetDataPointer(lock, &size, &buffer); hdc = CreateCompatibleDC(0); memset(&bi, 0, sizeof(bi)); bi.bmiHeader.biSize = sizeof(bi.bmiHeader); bi.bmiHeader.biWidth = width; bi.bmiHeader.biHeight = info.hbmColor ? -height: -height * 2; bi.bmiHeader.biPlanes = 1; bi.bmiHeader.biBitCount = 32; bi.bmiHeader.biCompression = BI_RGB; has_alpha = FALSE; if (info.hbmColor) { GetDIBits(hdc, info.hbmColor, 0, height, buffer, &bi, DIB_RGB_COLORS); if (bm.bmBitsPixel == 32) { /* If any pixel has a non-zero alpha, ignore hbmMask */ bits = (DWORD *)buffer; for (x = 0; x < width && !has_alpha; x++, bits++) { for (y = 0; y < height; y++) { if (*bits & 0xff000000) { has_alpha = TRUE; break; } } } } } else GetDIBits(hdc, info.hbmMask, 0, height, buffer, &bi, DIB_RGB_COLORS); if (!has_alpha) { DWORD *rgba; if (info.hbmMask) { BYTE *mask; mask = HeapAlloc(GetProcessHeap(), 0, size); if (!mask) { IWICBitmapLock_Release(lock); IWICBitmap_Release(*bitmap); DeleteDC(hdc); hr = E_OUTOFMEMORY; goto failed; } /* read alpha data from the mask */ GetDIBits(hdc, info.hbmMask, info.hbmColor ? 0 : height, height, mask, &bi, DIB_RGB_COLORS); for (y = 0; y < height; y++) { rgba = (DWORD *)(buffer + y * stride); bits = (DWORD *)(mask + y * stride); for (x = 0; x < width; x++, rgba++, bits++) { if (*bits) *rgba = 0; else *rgba |= 0xff000000; } } HeapFree(GetProcessHeap(), 0, mask); } else { /* set constant alpha of 255 */ for (y = 0; y < height; y++) { rgba = (DWORD *)(buffer + y * stride); for (x = 0; x < width; x++, rgba++) *rgba |= 0xff000000; } } } IWICBitmapLock_Release(lock); DeleteDC(hdc); failed: DeleteObject(info.hbmColor); DeleteObject(info.hbmMask); return hr; }
static HRESULT WINAPI ComponentFactory_CreateBitmapFromHBITMAP(IWICComponentFactory *iface, HBITMAP hbm, HPALETTE hpal, WICBitmapAlphaChannelOption option, IWICBitmap **bitmap) { BITMAP bm; HRESULT hr; WICPixelFormatGUID format; IWICBitmapLock *lock; UINT size, num_palette_entries = 0; PALETTEENTRY entry[256]; TRACE("(%p,%p,%p,%u,%p)\n", iface, hbm, hpal, option, bitmap); if (!bitmap) return E_INVALIDARG; if (GetObjectW(hbm, sizeof(bm), &bm) != sizeof(bm)) return WINCODEC_ERR_WIN32ERROR; if (hpal) { num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry); if (!num_palette_entries) return WINCODEC_ERR_WIN32ERROR; } /* TODO: Figure out the correct format for 16, 32, 64 bpp */ switch(bm.bmBitsPixel) { case 1: format = GUID_WICPixelFormat1bppIndexed; break; case 4: format = GUID_WICPixelFormat4bppIndexed; break; case 8: format = GUID_WICPixelFormat8bppIndexed; break; case 16: if (!get_16bpp_format(hbm, &format)) return E_INVALIDARG; break; case 24: format = GUID_WICPixelFormat24bppBGR; break; case 32: switch (option) { case WICBitmapUseAlpha: format = GUID_WICPixelFormat32bppBGRA; break; case WICBitmapUsePremultipliedAlpha: format = GUID_WICPixelFormat32bppPBGRA; break; case WICBitmapIgnoreAlpha: format = GUID_WICPixelFormat32bppBGR; break; default: return E_INVALIDARG; } break; case 48: format = GUID_WICPixelFormat48bppRGB; break; default: FIXME("unsupported %d bpp\n", bm.bmBitsPixel); return E_INVALIDARG; } hr = BitmapImpl_Create(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes, 0, NULL, &format, option, bitmap); if (hr != S_OK) return hr; hr = IWICBitmap_Lock(*bitmap, NULL, WICBitmapLockWrite, &lock); if (hr == S_OK) { BYTE *buffer; HDC hdc; char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])]; BITMAPINFO *bmi = (BITMAPINFO *)bmibuf; IWICBitmapLock_GetDataPointer(lock, &size, &buffer); hdc = CreateCompatibleDC(0); bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); bmi->bmiHeader.biBitCount = 0; GetDIBits(hdc, hbm, 0, 0, NULL, bmi, DIB_RGB_COLORS); bmi->bmiHeader.biHeight = -bm.bmHeight; GetDIBits(hdc, hbm, 0, bm.bmHeight, buffer, bmi, DIB_RGB_COLORS); DeleteDC(hdc); IWICBitmapLock_Release(lock); if (num_palette_entries) { IWICPalette *palette; WICColor colors[256]; UINT i; hr = PaletteImpl_Create(&palette); if (hr == S_OK) { for (i = 0; i < num_palette_entries; i++) colors[i] = 0xff000000 | entry[i].peRed << 16 | entry[i].peGreen << 8 | entry[i].peBlue; hr = IWICPalette_InitializeCustom(palette, colors, num_palette_entries); if (hr == S_OK) hr = IWICBitmap_SetPalette(*bitmap, palette); IWICPalette_Release(palette); } } } if (hr != S_OK) { IWICBitmap_Release(*bitmap); *bitmap = NULL; } return hr; }
static HRESULT WINAPI IMILBitmapImpl_Unlock(IMILBitmapSource *iface, IWICBitmapLock *lock) { TRACE("(%p,%p)\n", iface, lock); IWICBitmapLock_Release(lock); return S_OK; }