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 WINAPI ComponentFactory_CreateBitmap(IWICComponentFactory *iface, UINT uiWidth, UINT uiHeight, REFWICPixelFormatGUID pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap **ppIBitmap) { TRACE("(%p,%u,%u,%s,%u,%p)\n", iface, uiWidth, uiHeight, debugstr_guid(pixelFormat), option, ppIBitmap); return BitmapImpl_Create(uiWidth, uiHeight, pixelFormat, option, ppIBitmap); }
static HRESULT WINAPI ComponentFactory_CreateBitmapFromMemory(IWICComponentFactory *iface, UINT width, UINT height, REFWICPixelFormatGUID format, UINT stride, UINT size, BYTE *buffer, IWICBitmap **bitmap) { 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; return BitmapImpl_Create(width, height, stride, size, buffer, format, WICBitmapCacheOnLoad, bitmap); }
HRESULT WINAPI WICCreateBitmapFromSectionEx(UINT width, UINT height, REFWICPixelFormatGUID format, HANDLE section, UINT stride, UINT offset, WICSectionAccessLevel wicaccess, IWICBitmap **bitmap) { SYSTEM_INFO sysinfo; UINT bpp, access, size, view_offset, view_size; void *view; HRESULT hr; TRACE("%u,%u,%s,%p,%u,%u,%#x,%p\n", width, height, debugstr_guid(format), section, stride, offset, wicaccess, bitmap); if (!width || !height || !section || !bitmap) return E_INVALIDARG; hr = get_pixelformat_bpp(format, &bpp); if (FAILED(hr)) return hr; switch (wicaccess) { case WICSectionAccessLevelReadWrite: access = FILE_MAP_READ | FILE_MAP_WRITE; break; case WICSectionAccessLevelRead: access = FILE_MAP_READ; break; default: FIXME("unsupported access %#x\n", wicaccess); return E_INVALIDARG; } if (!stride) stride = (((bpp * width) + 31) / 32) * 4; size = stride * height; if (size / height != stride) return E_INVALIDARG; GetSystemInfo(&sysinfo); view_offset = offset - (offset % sysinfo.dwAllocationGranularity); view_size = size + (offset - view_offset); view = MapViewOfFile(section, access, 0, view_offset, view_size); if (!view) return HRESULT_FROM_WIN32(GetLastError()); offset -= view_offset; hr = BitmapImpl_Create(width, height, stride, 0, view, offset, format, WICBitmapCacheOnLoad, bitmap); if (FAILED(hr)) UnmapViewOfFile(view); return hr; }
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; }