dlls/d2d1/wic_render_target.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 "initguid.h"
  21 #include "wincodec.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  24
  25 static inline struct d2d_wic_render_target *impl_from_IUnknown(IUnknown *iface)
  26 {
  27     return CONTAINING_RECORD(iface, struct d2d_wic_render_target, IUnknown_iface);
  28 }
  29
  30 static HRESULT d2d_wic_render_target_present(IUnknown *outer_unknown)
  31 {
  32     struct d2d_wic_render_target *render_target = impl_from_IUnknown(outer_unknown);
  33     D3D10_MAPPED_TEXTURE2D mapped_texture;
  34     ID3D10Resource *src_resource;
  35     IWICBitmapLock *bitmap_lock;
  36     UINT dst_size, dst_pitch;
  37     ID3D10Device *device;
  38     WICRect dst_rect;
  39     BYTE *src, *dst;
  40     unsigned int i;
  41     HRESULT hr;
  42
  43     if (FAILED(hr = IDXGISurface_QueryInterface(render_target->dxgi_surface,
  44             &IID_ID3D10Resource, (void **)&src_resource)))
  45     {
  46         ERR("Failed to get source resource interface, hr %#x.\n", hr);
  47         goto end;
  48     }
  49
  50     ID3D10Texture2D_GetDevice(render_target->readback_texture, &device);
  51     ID3D10Device_CopyResource(device, (ID3D10Resource *)render_target->readback_texture, src_resource);
  52     ID3D10Device_Release(device);
  53     ID3D10Resource_Release(src_resource);
  54
  55     dst_rect.X = 0;
  56     dst_rect.Y = 0;
  57     dst_rect.Width = render_target->width;
  58     dst_rect.Height = render_target->height;
  59     if (FAILED(hr = IWICBitmap_Lock(render_target->bitmap, &dst_rect, WICBitmapLockWrite, &bitmap_lock)))
  60     {
  61         ERR("Failed to lock destination bitmap, hr %#x.\n", hr);
  62         goto end;
  63     }
  64
  65     if (FAILED(hr = IWICBitmapLock_GetDataPointer(bitmap_lock, &dst_size, &dst)))
  66     {
  67         ERR("Failed to get data pointer, hr %#x.\n", hr);
  68         IWICBitmapLock_Release(bitmap_lock);
  69         goto end;
  70     }
  71
  72     if (FAILED(hr = IWICBitmapLock_GetStride(bitmap_lock, &dst_pitch)))
  73     {
  74         ERR("Failed to get stride, hr %#x.\n", hr);
  75         IWICBitmapLock_Release(bitmap_lock);
  76         goto end;
  77     }
  78
  79     if (FAILED(hr = ID3D10Texture2D_Map(render_target->readback_texture, 0, D3D10_MAP_READ, 0, &mapped_texture)))
  80     {
  81         ERR("Failed to map readback texture, hr %#x.\n", hr);
  82         IWICBitmapLock_Release(bitmap_lock);
  83         goto end;
  84     }
  85
  86     src = mapped_texture.pData;
  87
  88     for (i = 0; i < render_target->height; ++i)
  89     {
  90         memcpy(dst, src, render_target->bpp * render_target->width);
  91         src += mapped_texture.RowPitch;
  92         dst += dst_pitch;
  93     }
  94
  95     ID3D10Texture2D_Unmap(render_target->readback_texture, 0);
  96     IWICBitmapLock_Release(bitmap_lock);
  97
  98 end:
  99     return S_OK;
 100 }
 101
 102 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_QueryInterface(IUnknown *iface, REFIID iid, void **out)
 103 {
 104     struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface);
 105
 106     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 107
 108     return IUnknown_QueryInterface(render_target->dxgi_inner, iid, out);
 109 }
 110
 111 static ULONG STDMETHODCALLTYPE d2d_wic_render_target_AddRef(IUnknown *iface)
 112 {
 113     struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface);
 114     ULONG refcount = InterlockedIncrement(&render_target->refcount);
 115
 116     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 117
 118     return refcount;
 119 }
 120
 121 static ULONG STDMETHODCALLTYPE d2d_wic_render_target_Release(IUnknown *iface)
 122 {
 123     struct d2d_wic_render_target *render_target = impl_from_IUnknown(iface);
 124     ULONG refcount = InterlockedDecrement(&render_target->refcount);
 125
 126     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 127
 128     if (!refcount)
 129     {
 130         IWICBitmap_Release(render_target->bitmap);
 131         ID3D10Texture2D_Release(render_target->readback_texture);
 132         IUnknown_Release(render_target->dxgi_inner);
 133         IDXGISurface_Release(render_target->dxgi_surface);
 134         heap_free(render_target);
 135     }
 136
 137     return refcount;
 138 }
 139
 140 static const struct IUnknownVtbl d2d_wic_render_target_vtbl =
 141 {
 142     d2d_wic_render_target_QueryInterface,
 143     d2d_wic_render_target_AddRef,
 144     d2d_wic_render_target_Release,
 145 };
 146
 147 static const struct d2d_device_context_ops d2d_wic_render_target_ops =
 148 {
 149     d2d_wic_render_target_present,
 150 };
 151
 152 HRESULT d2d_wic_render_target_init(struct d2d_wic_render_target *render_target, ID2D1Factory1 *factory,
 153         ID3D10Device1 *d3d_device, IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc)
 154 {
 155     D3D10_TEXTURE2D_DESC texture_desc;
 156     ID3D10Texture2D *texture;
 157     IDXGIDevice *dxgi_device;
 158     ID2D1Device *device;
 159     HRESULT hr;
 160
 161     render_target->IUnknown_iface.lpVtbl = &d2d_wic_render_target_vtbl;
 162
 163     if (FAILED(hr = IWICBitmap_GetSize(bitmap, &render_target->width, &render_target->height)))
 164     {
 165         WARN("Failed to get bitmap dimensions, hr %#x.\n", hr);
 166         return hr;
 167     }
 168
 169     texture_desc.Width = render_target->width;
 170     texture_desc.Height = render_target->height;
 171     texture_desc.MipLevels = 1;
 172     texture_desc.ArraySize = 1;
 173
 174     texture_desc.Format = desc->pixelFormat.format;
 175     if (texture_desc.Format == DXGI_FORMAT_UNKNOWN)
 176     {
 177         WICPixelFormatGUID bitmap_format;
 178
 179         if (FAILED(hr = IWICBitmap_GetPixelFormat(bitmap, &bitmap_format)))
 180         {
 181             WARN("Failed to get bitmap format, hr %#x.\n", hr);
 182             return hr;
 183         }
 184
 185         if (IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppPBGRA)
 186                 || IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppBGR))
 187         {
 188             texture_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
 189         }
 190         else
 191         {
 192             WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&bitmap_format));
 193             return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 194         }
 195     }
 196
 197     switch (texture_desc.Format)
 198     {
 199         case DXGI_FORMAT_B8G8R8A8_UNORM:
 200             render_target->bpp = 4;
 201             break;
 202
 203         default:
 204             FIXME("Unhandled format %#x.\n", texture_desc.Format);
 205             return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 206     }
 207
 208     texture_desc.SampleDesc.Count = 1;
 209     texture_desc.SampleDesc.Quality = 0;
 210     texture_desc.Usage = D3D10_USAGE_DEFAULT;
 211     texture_desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
 212     texture_desc.CPUAccessFlags = 0;
 213     texture_desc.MiscFlags = desc->usage & D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE ?
 214             D3D10_RESOURCE_MISC_GDI_COMPATIBLE : 0;
 215
 216     if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &texture)))
 217     {
 218         WARN("Failed to create texture, hr %#x.\n", hr);
 219         return hr;
 220     }
 221
 222     hr = ID3D10Texture2D_QueryInterface(texture, &IID_IDXGISurface, (void **)&render_target->dxgi_surface);
 223     ID3D10Texture2D_Release(texture);
 224     if (FAILED(hr))
 225     {
 226         WARN("Failed to get DXGI surface interface, hr %#x.\n", hr);
 227         return hr;
 228     }
 229
 230     texture_desc.Usage = D3D10_USAGE_STAGING;
 231     texture_desc.BindFlags = 0;
 232     texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
 233     texture_desc.MiscFlags = 0;
 234
 235     if (FAILED(hr = ID3D10Device1_CreateTexture2D(d3d_device, &texture_desc, NULL, &render_target->readback_texture)))
 236     {
 237         WARN("Failed to create readback texture, hr %#x.\n", hr);
 238         IDXGISurface_Release(render_target->dxgi_surface);
 239         return hr;
 240     }
 241
 242     if (FAILED(hr = ID3D10Device1_QueryInterface(d3d_device, &IID_IDXGIDevice, (void **)&dxgi_device)))
 243     {
 244         WARN("Failed to get DXGI device, hr %#x.\n", hr);
 245         IDXGISurface_Release(render_target->dxgi_surface);
 246         return hr;
 247     }
 248
 249     hr = ID2D1Factory1_CreateDevice(factory, dxgi_device, &device);
 250     IDXGIDevice_Release(dxgi_device);
 251     if (FAILED(hr))
 252     {
 253         WARN("Failed to create D2D device, hr %#x.\n", hr);
 254         IDXGISurface_Release(render_target->dxgi_surface);
 255         return hr;
 256     }
 257
 258     hr = d2d_d3d_create_render_target(device, render_target->dxgi_surface, &render_target->IUnknown_iface,
 259             &d2d_wic_render_target_ops, desc, (void **)&render_target->dxgi_inner);
 260     ID2D1Device_Release(device);
 261     if (FAILED(hr))
 262     {
 263         WARN("Failed to create DXGI surface render target, hr %#x.\n", hr);
 264         ID3D10Texture2D_Release(render_target->readback_texture);
 265         IDXGISurface_Release(render_target->dxgi_surface);
 266         return hr;
 267     }
 268
 269     if (FAILED(hr = IUnknown_QueryInterface(render_target->dxgi_inner,
 270             &IID_ID2D1RenderTarget, (void **)&render_target->dxgi_target)))
 271     {
 272         WARN("Failed to retrieve ID2D1RenderTarget interface, hr %#x.\n", hr);
 273         IUnknown_Release(render_target->dxgi_inner);
 274         ID3D10Texture2D_Release(render_target->readback_texture);
 275         IDXGISurface_Release(render_target->dxgi_surface);
 276         return hr;
 277     }
 278
 279     render_target->bitmap = bitmap;
 280     IWICBitmap_AddRef(bitmap);
 281
 282     return S_OK;
 283 }