dlls/d2d1/bitmap.c

   1 /*
   2  * Copyright 2014 Henri Verbeet for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "d2d1_private.h"
  20 #include "wincodec.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  23
  24 static inline struct d2d_bitmap *impl_from_ID2D1Bitmap1(ID2D1Bitmap1 *iface)
  25 {
  26     return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface);
  27 }
  28
  29 static HRESULT STDMETHODCALLTYPE d2d_bitmap_QueryInterface(ID2D1Bitmap1 *iface, REFIID iid, void **out)
  30 {
  31     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  32
  33     if (IsEqualGUID(iid, &IID_ID2D1Bitmap1)
  34             || IsEqualGUID(iid, &IID_ID2D1Bitmap)
  35             || IsEqualGUID(iid, &IID_ID2D1Image)
  36             || IsEqualGUID(iid, &IID_ID2D1Resource)
  37             || IsEqualGUID(iid, &IID_IUnknown))
  38     {
  39         ID2D1Bitmap1_AddRef(iface);
  40         *out = iface;
  41         return S_OK;
  42     }
  43
  44     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  45
  46     *out = NULL;
  47     return E_NOINTERFACE;
  48 }
  49
  50 static ULONG STDMETHODCALLTYPE d2d_bitmap_AddRef(ID2D1Bitmap1 *iface)
  51 {
  52     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
  53     ULONG refcount = InterlockedIncrement(&bitmap->refcount);
  54
  55     TRACE("%p increasing refcount to %lu.\n", iface, refcount);
  56
  57     return refcount;
  58 }
  59
  60 static ULONG STDMETHODCALLTYPE d2d_bitmap_Release(ID2D1Bitmap1 *iface)
  61 {
  62     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
  63     ULONG refcount = InterlockedDecrement(&bitmap->refcount);
  64
  65     TRACE("%p decreasing refcount to %lu.\n", iface, refcount);
  66
  67     if (!refcount)
  68     {
  69         if (bitmap->srv)
  70             ID3D11ShaderResourceView_Release(bitmap->srv);
  71         if (bitmap->rtv)
  72             ID3D11RenderTargetView_Release(bitmap->rtv);
  73         if (bitmap->surface)
  74             IDXGISurface_Release(bitmap->surface);
  75         ID3D11Resource_Release(bitmap->resource);
  76         ID2D1Factory_Release(bitmap->factory);
  77         heap_free(bitmap);
  78     }
  79
  80     return refcount;
  81 }
  82
  83 static void STDMETHODCALLTYPE d2d_bitmap_GetFactory(ID2D1Bitmap1 *iface, ID2D1Factory **factory)
  84 {
  85     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
  86
  87     TRACE("iface %p, factory %p.\n", iface, factory);
  88
  89     ID2D1Factory_AddRef(*factory = bitmap->factory);
  90 }
  91
  92 static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_bitmap_GetSize(ID2D1Bitmap1 *iface, D2D1_SIZE_F *size)
  93 {
  94     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
  95
  96     TRACE("iface %p, size %p.\n", iface, size);
  97
  98     size->width = bitmap->pixel_size.width / (bitmap->dpi_x / 96.0f);
  99     size->height = bitmap->pixel_size.height / (bitmap->dpi_y / 96.0f);
 100     return size;
 101 }
 102
 103 static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_bitmap_GetPixelSize(ID2D1Bitmap1 *iface, D2D1_SIZE_U *pixel_size)
 104 {
 105     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 106
 107     TRACE("iface %p, pixel_size %p.\n", iface, pixel_size);
 108
 109     *pixel_size = bitmap->pixel_size;
 110     return pixel_size;
 111 }
 112
 113 static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_bitmap_GetPixelFormat(ID2D1Bitmap1 *iface, D2D1_PIXEL_FORMAT *format)
 114 {
 115     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 116
 117     TRACE("iface %p, format %p.\n", iface, format);
 118
 119     *format = bitmap->format;
 120     return format;
 121 }
 122
 123 static void STDMETHODCALLTYPE d2d_bitmap_GetDpi(ID2D1Bitmap1 *iface, float *dpi_x, float *dpi_y)
 124 {
 125     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 126
 127     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 128
 129     *dpi_x = bitmap->dpi_x;
 130     *dpi_y = bitmap->dpi_y;
 131 }
 132
 133 static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromBitmap(ID2D1Bitmap1 *iface,
 134         const D2D1_POINT_2U *dst_point, ID2D1Bitmap *bitmap, const D2D1_RECT_U *src_rect)
 135 {
 136     struct d2d_bitmap *src_bitmap = unsafe_impl_from_ID2D1Bitmap(bitmap);
 137     struct d2d_bitmap *dst_bitmap = impl_from_ID2D1Bitmap1(iface);
 138     ID3D11DeviceContext *context;
 139     ID3D11Device *device;
 140     D3D11_BOX box;
 141
 142     TRACE("iface %p, dst_point %p, bitmap %p, src_rect %p.\n", iface, dst_point, bitmap, src_rect);
 143
 144     if (src_rect)
 145     {
 146         box.left = src_rect->left;
 147         box.top = src_rect->top;
 148         box.front = 0;
 149         box.right = src_rect->right;
 150         box.bottom = src_rect->bottom;
 151         box.back = 1;
 152     }
 153
 154     ID3D11Resource_GetDevice(dst_bitmap->resource, &device);
 155     ID3D11Device_GetImmediateContext(device, &context);
 156     ID3D11DeviceContext_CopySubresourceRegion(context, dst_bitmap->resource, 0,
 157             dst_point ? dst_point->x : 0, dst_point ? dst_point->y : 0, 0,
 158             src_bitmap->resource, 0, src_rect ? &box : NULL);
 159     ID3D11DeviceContext_Release(context);
 160     ID3D11Device_Release(device);
 161
 162     return S_OK;
 163 }
 164
 165 static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromRenderTarget(ID2D1Bitmap1 *iface,
 166         const D2D1_POINT_2U *dst_point, ID2D1RenderTarget *render_target, const D2D1_RECT_U *src_rect)
 167 {
 168     FIXME("iface %p, dst_point %p, render_target %p, src_rect %p stub!\n", iface, dst_point, render_target, src_rect);
 169
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT STDMETHODCALLTYPE d2d_bitmap_CopyFromMemory(ID2D1Bitmap1 *iface,
 174         const D2D1_RECT_U *dst_rect, const void *src_data, UINT32 pitch)
 175 {
 176     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 177     ID3D11DeviceContext *context;
 178     ID3D11Device *device;
 179     D3D11_BOX box;
 180
 181     TRACE("iface %p, dst_rect %p, src_data %p, pitch %u.\n", iface, dst_rect, src_data, pitch);
 182
 183     if (dst_rect)
 184     {
 185         box.left = dst_rect->left;
 186         box.top = dst_rect->top;
 187         box.front = 0;
 188         box.right = dst_rect->right;
 189         box.bottom = dst_rect->bottom;
 190         box.back = 1;
 191     }
 192
 193     ID3D11Resource_GetDevice(bitmap->resource, &device);
 194     ID3D11Device_GetImmediateContext(device, &context);
 195     ID3D11DeviceContext_UpdateSubresource(context, bitmap->resource, 0, dst_rect ? &box : NULL, src_data, pitch, 0);
 196     ID3D11DeviceContext_Release(context);
 197     ID3D11Device_Release(device);
 198
 199     return S_OK;
 200 }
 201
 202 static void STDMETHODCALLTYPE d2d_bitmap_GetColorContext(ID2D1Bitmap1 *iface, ID2D1ColorContext **context)
 203 {
 204     FIXME("iface %p, context %p stub!\n", iface, context);
 205 }
 206
 207 static D2D1_BITMAP_OPTIONS STDMETHODCALLTYPE d2d_bitmap_GetOptions(ID2D1Bitmap1 *iface)
 208 {
 209     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 210
 211     TRACE("iface %p.\n", iface);
 212
 213     return bitmap->options;
 214 }
 215
 216 static HRESULT STDMETHODCALLTYPE d2d_bitmap_GetSurface(ID2D1Bitmap1 *iface, IDXGISurface **surface)
 217 {
 218     struct d2d_bitmap *bitmap = impl_from_ID2D1Bitmap1(iface);
 219
 220     TRACE("iface %p, surface %p.\n", iface, surface);
 221
 222     *surface = bitmap->surface;
 223     if (*surface)
 224         IDXGISurface_AddRef(*surface);
 225
 226     return *surface ? S_OK : D2DERR_INVALID_CALL;
 227 }
 228
 229 static HRESULT STDMETHODCALLTYPE d2d_bitmap_Map(ID2D1Bitmap1 *iface, D2D1_MAP_OPTIONS options,
 230         D2D1_MAPPED_RECT *mapped_rect)
 231 {
 232     FIXME("iface %p, options %#x, mapped_rect %p stub!\n", iface, options, mapped_rect);
 233
 234     return E_NOTIMPL;
 235 }
 236
 237 static HRESULT STDMETHODCALLTYPE d2d_bitmap_Unmap(ID2D1Bitmap1 *iface)
 238 {
 239     FIXME("iface %p stub!\n", iface);
 240
 241     return E_NOTIMPL;
 242 }
 243
 244 static const struct ID2D1Bitmap1Vtbl d2d_bitmap_vtbl =
 245 {
 246     d2d_bitmap_QueryInterface,
 247     d2d_bitmap_AddRef,
 248     d2d_bitmap_Release,
 249     d2d_bitmap_GetFactory,
 250     d2d_bitmap_GetSize,
 251     d2d_bitmap_GetPixelSize,
 252     d2d_bitmap_GetPixelFormat,
 253     d2d_bitmap_GetDpi,
 254     d2d_bitmap_CopyFromBitmap,
 255     d2d_bitmap_CopyFromRenderTarget,
 256     d2d_bitmap_CopyFromMemory,
 257     d2d_bitmap_GetColorContext,
 258     d2d_bitmap_GetOptions,
 259     d2d_bitmap_GetSurface,
 260     d2d_bitmap_Map,
 261     d2d_bitmap_Unmap,
 262 };
 263
 264 static BOOL format_supported(const D2D1_PIXEL_FORMAT *format)
 265 {
 266     unsigned int i;
 267
 268     static const D2D1_PIXEL_FORMAT supported_formats[] =
 269     {
 270         {DXGI_FORMAT_R32G32B32A32_FLOAT,    D2D1_ALPHA_MODE_PREMULTIPLIED},
 271         {DXGI_FORMAT_R32G32B32A32_FLOAT,    D2D1_ALPHA_MODE_IGNORE       },
 272         {DXGI_FORMAT_R16G16B16A16_FLOAT,    D2D1_ALPHA_MODE_PREMULTIPLIED},
 273         {DXGI_FORMAT_R16G16B16A16_FLOAT,    D2D1_ALPHA_MODE_IGNORE       },
 274         {DXGI_FORMAT_R16G16B16A16_UNORM,    D2D1_ALPHA_MODE_PREMULTIPLIED},
 275         {DXGI_FORMAT_R16G16B16A16_UNORM,    D2D1_ALPHA_MODE_IGNORE       },
 276         {DXGI_FORMAT_R8G8B8A8_UNORM,        D2D1_ALPHA_MODE_PREMULTIPLIED},
 277         {DXGI_FORMAT_R8G8B8A8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
 278         {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_PREMULTIPLIED},
 279         {DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_IGNORE       },
 280         {DXGI_FORMAT_A8_UNORM,              D2D1_ALPHA_MODE_PREMULTIPLIED},
 281         {DXGI_FORMAT_A8_UNORM,              D2D1_ALPHA_MODE_STRAIGHT     },
 282         {DXGI_FORMAT_B8G8R8A8_UNORM,        D2D1_ALPHA_MODE_PREMULTIPLIED},
 283         {DXGI_FORMAT_B8G8R8A8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
 284         {DXGI_FORMAT_B8G8R8X8_UNORM,        D2D1_ALPHA_MODE_IGNORE       },
 285         {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_PREMULTIPLIED},
 286         {DXGI_FORMAT_B8G8R8A8_UNORM_SRGB,   D2D1_ALPHA_MODE_IGNORE       },
 287     };
 288
 289     for (i = 0; i < ARRAY_SIZE(supported_formats); ++i)
 290     {
 291         if (supported_formats[i].format == format->format
 292                 && supported_formats[i].alphaMode == format->alphaMode)
 293             return TRUE;
 294     }
 295
 296     return FALSE;
 297 }
 298
 299 static void d2d_bitmap_init(struct d2d_bitmap *bitmap, struct d2d_device_context *context,
 300         ID3D11Resource *resource, D2D1_SIZE_U size, const D2D1_BITMAP_PROPERTIES1 *desc)
 301 {
 302     ID3D11Device *d3d_device;
 303     HRESULT hr;
 304
 305     bitmap->ID2D1Bitmap1_iface.lpVtbl = &d2d_bitmap_vtbl;
 306     bitmap->refcount = 1;
 307     ID2D1Factory_AddRef(bitmap->factory = context->factory);
 308     ID3D11Resource_AddRef(bitmap->resource = resource);
 309     bitmap->pixel_size = size;
 310     bitmap->format = desc->pixelFormat;
 311     bitmap->dpi_x = desc->dpiX;
 312     bitmap->dpi_y = desc->dpiY;
 313     bitmap->options = desc->bitmapOptions;
 314
 315     if (d2d_device_context_is_dxgi_target(context))
 316         ID3D11Resource_QueryInterface(resource, &IID_IDXGISurface, (void **)&bitmap->surface);
 317
 318     ID3D11Resource_GetDevice(resource, &d3d_device);
 319     if (bitmap->options & D2D1_BITMAP_OPTIONS_TARGET)
 320     {
 321         if (FAILED(hr = ID3D11Device_CreateRenderTargetView(d3d_device, resource, NULL, &bitmap->rtv)))
 322             WARN("Failed to create RTV, hr %#lx.\n", hr);
 323     }
 324
 325     if (!(bitmap->options & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
 326     {
 327         if (FAILED(hr = ID3D11Device_CreateShaderResourceView(d3d_device, resource, NULL, &bitmap->srv)))
 328             WARN("Failed to create SRV, hr %#lx.\n", hr);
 329     }
 330     ID3D11Device_Release(d3d_device);
 331
 332     if (bitmap->dpi_x == 0.0f && bitmap->dpi_y == 0.0f)
 333     {
 334         bitmap->dpi_x = 96.0f;
 335         bitmap->dpi_y = 96.0f;
 336     }
 337 }
 338
 339 HRESULT d2d_bitmap_create(struct d2d_device_context *context, D2D1_SIZE_U size, const void *src_data,
 340         UINT32 pitch, const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
 341 {
 342     D3D11_SUBRESOURCE_DATA resource_data;
 343     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
 344     D3D11_TEXTURE2D_DESC texture_desc;
 345     ID3D11Texture2D *texture;
 346     HRESULT hr;
 347
 348     if (!format_supported(&desc->pixelFormat))
 349     {
 350         WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
 351                 desc->pixelFormat.format, desc->pixelFormat.alphaMode);
 352         return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 353     }
 354
 355     if (desc->dpiX == 0.0f && desc->dpiY == 0.0f)
 356     {
 357         bitmap_desc = *desc;
 358         bitmap_desc.dpiX = context->desc.dpiX;
 359         bitmap_desc.dpiY = context->desc.dpiY;
 360         desc = &bitmap_desc;
 361     }
 362     else if (desc->dpiX <= 0.0f || desc->dpiY <= 0.0f)
 363     {
 364         return E_INVALIDARG;
 365     }
 366
 367     texture_desc.Width = size.width;
 368     texture_desc.Height = size.height;
 369     if (!texture_desc.Width || !texture_desc.Height)
 370         texture_desc.Width = texture_desc.Height = 1;
 371     texture_desc.MipLevels = 1;
 372     texture_desc.ArraySize = 1;
 373     texture_desc.Format = desc->pixelFormat.format;
 374     texture_desc.SampleDesc.Count = 1;
 375     texture_desc.SampleDesc.Quality = 0;
 376     texture_desc.Usage = D3D11_USAGE_DEFAULT;
 377     texture_desc.BindFlags = 0;
 378     if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_TARGET)
 379         texture_desc.BindFlags |= D3D11_BIND_RENDER_TARGET;
 380     if (!(desc->bitmapOptions & D2D1_BITMAP_OPTIONS_CANNOT_DRAW))
 381         texture_desc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
 382     texture_desc.CPUAccessFlags = 0;
 383     texture_desc.MiscFlags = 0;
 384     if (desc->bitmapOptions & D2D1_BITMAP_OPTIONS_GDI_COMPATIBLE)
 385         texture_desc.MiscFlags |= D3D11_RESOURCE_MISC_GDI_COMPATIBLE;
 386
 387     resource_data.pSysMem = src_data;
 388     resource_data.SysMemPitch = pitch;
 389
 390     if (FAILED(hr = ID3D11Device1_CreateTexture2D(context->d3d_device, &texture_desc,
 391             src_data ? &resource_data : NULL, &texture)))
 392     {
 393         ERR("Failed to create texture, hr %#lx.\n", hr);
 394         return hr;
 395     }
 396
 397     if ((*bitmap = heap_alloc_zero(sizeof(**bitmap))))
 398     {
 399         d2d_bitmap_init(*bitmap, context, (ID3D11Resource *)texture, size, desc);
 400         TRACE("Created bitmap %p.\n", *bitmap);
 401     }
 402     ID3D11Texture2D_Release(texture);
 403
 404     return *bitmap ? S_OK : E_OUTOFMEMORY;
 405 }
 406
 407 HRESULT d2d_bitmap_create_shared(struct d2d_device_context *context, REFIID iid, void *data,
 408         const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
 409 {
 410     D2D1_BITMAP_PROPERTIES1 d;
 411
 412     if (IsEqualGUID(iid, &IID_ID2D1Bitmap))
 413     {
 414         struct d2d_bitmap *src_impl = unsafe_impl_from_ID2D1Bitmap(data);
 415         ID3D11Device *device;
 416         HRESULT hr = S_OK;
 417
 418         if (src_impl->factory != context->factory)
 419         {
 420             hr = D2DERR_WRONG_FACTORY;
 421             goto failed;
 422         }
 423
 424         ID3D11Resource_GetDevice(src_impl->resource, &device);
 425         ID3D11Device_Release(device);
 426         if (device != (ID3D11Device *)context->d3d_device)
 427         {
 428             hr = D2DERR_UNSUPPORTED_OPERATION;
 429             goto failed;
 430         }
 431
 432         if (!desc)
 433         {
 434             d.pixelFormat = src_impl->format;
 435             d.dpiX = src_impl->dpi_x;
 436             d.dpiY = src_impl->dpi_y;
 437             d.bitmapOptions = src_impl->options;
 438             d.colorContext = NULL;
 439             desc = &d;
 440         }
 441
 442         if (!format_supported(&desc->pixelFormat))
 443         {
 444             WARN("Tried to create bitmap with unsupported format {%#x / %#x}.\n",
 445                     desc->pixelFormat.format, desc->pixelFormat.alphaMode);
 446             hr = D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 447             goto failed;
 448         }
 449
 450         if (!(*bitmap = heap_alloc_zero(sizeof(**bitmap))))
 451         {
 452             hr = E_OUTOFMEMORY;
 453             goto failed;
 454         }
 455
 456         d2d_bitmap_init(*bitmap, context, src_impl->resource, src_impl->pixel_size, desc);
 457         TRACE("Created bitmap %p.\n", *bitmap);
 458
 459     failed:
 460         return hr;
 461     }
 462
 463     if (IsEqualGUID(iid, &IID_IDXGISurface) || IsEqualGUID(iid, &IID_IDXGISurface1))
 464     {
 465         DXGI_SURFACE_DESC surface_desc;
 466         IDXGISurface *surface = data;
 467         ID3D11Resource *resource;
 468         D2D1_SIZE_U pixel_size;
 469         ID3D11Device *device;
 470         HRESULT hr;
 471
 472         if (FAILED(IDXGISurface_QueryInterface(surface, &IID_ID3D11Resource, (void **)&resource)))
 473         {
 474             WARN("Failed to get d3d resource from dxgi surface.\n");
 475             return E_FAIL;
 476         }
 477
 478         ID3D11Resource_GetDevice(resource, &device);
 479         ID3D11Device_Release(device);
 480         if (device != (ID3D11Device *)context->d3d_device)
 481         {
 482             ID3D11Resource_Release(resource);
 483             return D2DERR_UNSUPPORTED_OPERATION;
 484         }
 485
 486         if (!(*bitmap = heap_alloc_zero(sizeof(**bitmap))))
 487         {
 488             ID3D11Resource_Release(resource);
 489             return E_OUTOFMEMORY;
 490         }
 491
 492
 493         if (FAILED(hr = IDXGISurface_GetDesc(surface, &surface_desc)))
 494         {
 495             WARN("Failed to get surface desc, hr %#lx.\n", hr);
 496             ID3D11Resource_Release(resource);
 497             return hr;
 498         }
 499
 500         if (!desc)
 501         {
 502             memset(&d, 0, sizeof(d));
 503             d.pixelFormat.format = surface_desc.Format;
 504         }
 505         else
 506         {
 507             d = *desc;
 508             if (d.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
 509                 d.pixelFormat.format = surface_desc.Format;
 510         }
 511
 512         if (d.dpiX == 0.0f || d.dpiY == 0.0f)
 513         {
 514             if (d.dpiX == 0.0f)
 515                 d.dpiX = context->desc.dpiX;
 516             if (d.dpiY == 0.0f)
 517                 d.dpiY = context->desc.dpiY;
 518         }
 519
 520         pixel_size.width = surface_desc.Width;
 521         pixel_size.height = surface_desc.Height;
 522
 523         d2d_bitmap_init(*bitmap, context, resource, pixel_size, &d);
 524         ID3D11Resource_Release(resource);
 525         TRACE("Created bitmap %p.\n", *bitmap);
 526
 527         return S_OK;
 528     }
 529
 530     WARN("Unhandled interface %s.\n", debugstr_guid(iid));
 531
 532     return E_INVALIDARG;
 533 }
 534
 535 HRESULT d2d_bitmap_create_from_wic_bitmap(struct d2d_device_context *context, IWICBitmapSource *bitmap_source,
 536         const D2D1_BITMAP_PROPERTIES1 *desc, struct d2d_bitmap **bitmap)
 537 {
 538     const D2D1_PIXEL_FORMAT *d2d_format;
 539     D2D1_BITMAP_PROPERTIES1 bitmap_desc;
 540     WICPixelFormatGUID wic_format;
 541     unsigned int bpp, data_size;
 542     D2D1_SIZE_U size;
 543     unsigned int i;
 544     WICRect rect;
 545     UINT32 pitch;
 546     HRESULT hr;
 547     void *data;
 548
 549     static const struct
 550     {
 551         const WICPixelFormatGUID *wic;
 552         D2D1_PIXEL_FORMAT d2d;
 553     }
 554     format_lookup[] =
 555     {
 556         {&GUID_WICPixelFormat32bppPBGRA, {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
 557         {&GUID_WICPixelFormat32bppPRGBA, {DXGI_FORMAT_R8G8B8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED}},
 558         {&GUID_WICPixelFormat32bppBGR,   {DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE}},
 559     };
 560
 561     if (FAILED(hr = IWICBitmapSource_GetSize(bitmap_source, &size.width, &size.height)))
 562     {
 563         WARN("Failed to get bitmap size, hr %#lx.\n", hr);
 564         return hr;
 565     }
 566
 567     if (!desc)
 568     {
 569         bitmap_desc.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
 570         bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
 571         bitmap_desc.dpiX = 0.0f;
 572         bitmap_desc.dpiY = 0.0f;
 573         bitmap_desc.bitmapOptions = 0;
 574         bitmap_desc.colorContext = NULL;
 575     }
 576     else
 577     {
 578         bitmap_desc = *desc;
 579     }
 580
 581     if (FAILED(hr = IWICBitmapSource_GetPixelFormat(bitmap_source, &wic_format)))
 582     {
 583         WARN("Failed to get bitmap format, hr %#lx.\n", hr);
 584         return hr;
 585     }
 586
 587     for (i = 0, d2d_format = NULL; i < ARRAY_SIZE(format_lookup); ++i)
 588     {
 589         if (IsEqualGUID(&wic_format, format_lookup[i].wic))
 590         {
 591             d2d_format = &format_lookup[i].d2d;
 592             break;
 593         }
 594     }
 595
 596     if (!d2d_format)
 597     {
 598         WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&wic_format));
 599         return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 600     }
 601
 602     if (bitmap_desc.pixelFormat.format == DXGI_FORMAT_UNKNOWN)
 603         bitmap_desc.pixelFormat.format = d2d_format->format;
 604     if (bitmap_desc.pixelFormat.alphaMode == D2D1_ALPHA_MODE_UNKNOWN)
 605         bitmap_desc.pixelFormat.alphaMode = d2d_format->alphaMode;
 606
 607     switch (bitmap_desc.pixelFormat.format)
 608     {
 609         case DXGI_FORMAT_B8G8R8A8_UNORM:
 610         case DXGI_FORMAT_R8G8B8A8_UNORM:
 611             bpp = 4;
 612             break;
 613
 614         default:
 615             FIXME("Unhandled format %#x.\n", bitmap_desc.pixelFormat.format);
 616             return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 617     }
 618
 619     pitch = ((bpp * size.width) + 15) & ~15;
 620     if (pitch / bpp < size.width)
 621         return E_OUTOFMEMORY;
 622     if (!(data = heap_calloc(size.height, pitch)))
 623         return E_OUTOFMEMORY;
 624     data_size = size.height * pitch;
 625
 626     rect.X = 0;
 627     rect.Y = 0;
 628     rect.Width = size.width;
 629     rect.Height = size.height;
 630     if (FAILED(hr = IWICBitmapSource_CopyPixels(bitmap_source, &rect, pitch, data_size, data)))
 631     {
 632         WARN("Failed to copy bitmap pixels, hr %#lx.\n", hr);
 633         heap_free(data);
 634         return hr;
 635     }
 636
 637     hr = d2d_bitmap_create(context, size, data, pitch, &bitmap_desc, bitmap);
 638
 639     heap_free(data);
 640
 641     return hr;
 642 }
 643
 644 struct d2d_bitmap *unsafe_impl_from_ID2D1Bitmap(ID2D1Bitmap *iface)
 645 {
 646     if (!iface)
 647         return NULL;
 648     assert(iface->lpVtbl == (ID2D1BitmapVtbl *)&d2d_bitmap_vtbl);
 649     return CONTAINING_RECORD(iface, struct d2d_bitmap, ID2D1Bitmap1_iface);
 650 }