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 "config.h"
  20 #include "wine/port.h"
  21
  22 #include "d2d1_private.h"
  23 #include "initguid.h"
  24 #include "wincodec.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(d2d);
  27
  28 static void sync_bitmap(struct d2d_wic_render_target *render_target)
  29 {
  30     D3D10_MAPPED_TEXTURE2D mapped_texture;
  31     ID3D10Resource *src_resource;
  32     IWICBitmapLock *bitmap_lock;
  33     UINT dst_size, dst_pitch;
  34     ID3D10Device *device;
  35     WICRect dst_rect;
  36     BYTE *src, *dst;
  37     unsigned int i;
  38     HRESULT hr;
  39
  40     if (FAILED(hr = IDXGISurface_QueryInterface(render_target->dxgi_surface,
  41             &IID_ID3D10Resource, (void **)&src_resource)))
  42     {
  43         ERR("Failed to get source resource interface, hr %#x.\n", hr);
  44         return;
  45     }
  46
  47     ID3D10Texture2D_GetDevice(render_target->readback_texture, &device);
  48     ID3D10Device_CopyResource(device, (ID3D10Resource *)render_target->readback_texture, src_resource);
  49     ID3D10Device_Release(device);
  50     ID3D10Resource_Release(src_resource);
  51
  52     dst_rect.X = 0;
  53     dst_rect.Y = 0;
  54     dst_rect.Width = render_target->width;
  55     dst_rect.Height = render_target->height;
  56     if (FAILED(hr = IWICBitmap_Lock(render_target->bitmap, &dst_rect, WICBitmapLockWrite, &bitmap_lock)))
  57     {
  58         ERR("Failed to lock destination bitmap, hr %#x.\n", hr);
  59         return;
  60     }
  61
  62     if (FAILED(hr = IWICBitmapLock_GetDataPointer(bitmap_lock, &dst_size, &dst)))
  63     {
  64         ERR("Failed to get data pointer, hr %#x.\n", hr);
  65         IWICBitmapLock_Release(bitmap_lock);
  66         return;
  67     }
  68
  69     if (FAILED(hr = IWICBitmapLock_GetStride(bitmap_lock, &dst_pitch)))
  70     {
  71         ERR("Failed to get stride, hr %#x.\n", hr);
  72         IWICBitmapLock_Release(bitmap_lock);
  73         return;
  74     }
  75
  76     if (FAILED(hr = ID3D10Texture2D_Map(render_target->readback_texture, 0, D3D10_MAP_READ, 0, &mapped_texture)))
  77     {
  78         ERR("Failed to map readback texture, hr %#x.\n", hr);
  79         IWICBitmapLock_Release(bitmap_lock);
  80         return;
  81     }
  82
  83     src = mapped_texture.pData;
  84
  85     for (i = 0; i < render_target->height; ++i)
  86     {
  87         memcpy(dst, src, render_target->bpp * render_target->width);
  88         src += mapped_texture.RowPitch;
  89         dst += dst_pitch;
  90     }
  91
  92     ID3D10Texture2D_Unmap(render_target->readback_texture, 0);
  93     IWICBitmapLock_Release(bitmap_lock);
  94 }
  95
  96 static inline struct d2d_wic_render_target *impl_from_ID2D1RenderTarget(ID2D1RenderTarget *iface)
  97 {
  98     return CONTAINING_RECORD(iface, struct d2d_wic_render_target, ID2D1RenderTarget_iface);
  99 }
 100
 101 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_QueryInterface(ID2D1RenderTarget *iface, REFIID iid, void **out)
 102 {
 103     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 104
 105     if (IsEqualGUID(iid, &IID_ID2D1RenderTarget)
 106             || IsEqualGUID(iid, &IID_ID2D1Resource)
 107             || IsEqualGUID(iid, &IID_IUnknown))
 108     {
 109         ID2D1RenderTarget_AddRef(iface);
 110         *out = iface;
 111         return S_OK;
 112     }
 113
 114     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 115
 116     *out = NULL;
 117     return E_NOINTERFACE;
 118 }
 119
 120 static ULONG STDMETHODCALLTYPE d2d_wic_render_target_AddRef(ID2D1RenderTarget *iface)
 121 {
 122     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 123     ULONG refcount = InterlockedIncrement(&render_target->refcount);
 124
 125     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 126
 127     return refcount;
 128 }
 129
 130 static ULONG STDMETHODCALLTYPE d2d_wic_render_target_Release(ID2D1RenderTarget *iface)
 131 {
 132     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 133     ULONG refcount = InterlockedDecrement(&render_target->refcount);
 134
 135     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 136
 137     if (!refcount)
 138     {
 139         IWICBitmap_Release(render_target->bitmap);
 140         ID3D10Texture2D_Release(render_target->readback_texture);
 141         ID2D1RenderTarget_Release(render_target->dxgi_target);
 142         IDXGISurface_Release(render_target->dxgi_surface);
 143         HeapFree(GetProcessHeap(), 0, render_target);
 144     }
 145
 146     return refcount;
 147 }
 148
 149 static void STDMETHODCALLTYPE d2d_wic_render_target_GetFactory(ID2D1RenderTarget *iface, ID2D1Factory **factory)
 150 {
 151     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 152
 153     TRACE("iface %p, factory %p.\n", iface, factory);
 154
 155     ID2D1RenderTarget_GetFactory(render_target->dxgi_target, factory);
 156 }
 157
 158 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateBitmap(ID2D1RenderTarget *iface,
 159         D2D1_SIZE_U size, const void *src_data, UINT32 pitch, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 160 {
 161     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 162
 163     TRACE("iface %p, size {%u, %u}, src_data %p, pitch %u, desc %p, bitmap %p.\n",
 164             iface, size.width, size.height, src_data, pitch, desc, bitmap);
 165
 166     return ID2D1RenderTarget_CreateBitmap(render_target->dxgi_target, size, src_data, pitch, desc, bitmap);
 167 }
 168
 169 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateBitmapFromWicBitmap(ID2D1RenderTarget *iface,
 170         IWICBitmapSource *bitmap_source, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 171 {
 172     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 173
 174     TRACE("iface %p, bitmap_source %p, desc %p, bitmap %p.\n",
 175             iface, bitmap_source, desc, bitmap);
 176
 177     return ID2D1RenderTarget_CreateBitmapFromWicBitmap(render_target->dxgi_target, bitmap_source, desc, bitmap);
 178 }
 179
 180 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateSharedBitmap(ID2D1RenderTarget *iface,
 181         REFIID iid, void *data, const D2D1_BITMAP_PROPERTIES *desc, ID2D1Bitmap **bitmap)
 182 {
 183     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 184
 185     TRACE("iface %p, iid %s, data %p, desc %p, bitmap %p.\n",
 186             iface, debugstr_guid(iid), data, desc, bitmap);
 187
 188     return ID2D1RenderTarget_CreateSharedBitmap(render_target->dxgi_target, iid, data, desc, bitmap);
 189 }
 190
 191 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateBitmapBrush(ID2D1RenderTarget *iface,
 192         ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc,
 193         const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1BitmapBrush **brush)
 194 {
 195     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 196
 197     TRACE("iface %p, bitmap %p, bitmap_brush_desc %p, brush_desc %p, brush %p.\n",
 198             iface, bitmap, bitmap_brush_desc, brush_desc, brush);
 199
 200     return ID2D1RenderTarget_CreateBitmapBrush(render_target->dxgi_target,
 201             bitmap, bitmap_brush_desc, brush_desc, brush);
 202 }
 203
 204 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateSolidColorBrush(ID2D1RenderTarget *iface,
 205         const D2D1_COLOR_F *color, const D2D1_BRUSH_PROPERTIES *desc, ID2D1SolidColorBrush **brush)
 206 {
 207     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 208
 209     TRACE("iface %p, color %p, desc %p, brush %p.\n", iface, color, desc, brush);
 210
 211     return ID2D1RenderTarget_CreateSolidColorBrush(render_target->dxgi_target, color, desc, brush);
 212 }
 213
 214 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateGradientStopCollection(ID2D1RenderTarget *iface,
 215         const D2D1_GRADIENT_STOP *stops, UINT32 stop_count, D2D1_GAMMA gamma, D2D1_EXTEND_MODE extend_mode,
 216         ID2D1GradientStopCollection **gradient)
 217 {
 218     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 219
 220     TRACE("iface %p, stops %p, stop_count %u, gamma %#x, extend_mode %#x, gradient %p.\n",
 221             iface, stops, stop_count, gamma, extend_mode, gradient);
 222
 223     return ID2D1RenderTarget_CreateGradientStopCollection(render_target->dxgi_target,
 224             stops, stop_count, gamma, extend_mode, gradient);
 225 }
 226
 227 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateLinearGradientBrush(ID2D1RenderTarget *iface,
 228         const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 229         ID2D1GradientStopCollection *gradient, ID2D1LinearGradientBrush **brush)
 230 {
 231     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 232
 233     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 234             iface, gradient_brush_desc, brush_desc, gradient, brush);
 235
 236     return ID2D1RenderTarget_CreateLinearGradientBrush(render_target->dxgi_target,
 237             gradient_brush_desc, brush_desc, gradient, brush);
 238 }
 239
 240 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateRadialGradientBrush(ID2D1RenderTarget *iface,
 241         const D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
 242         ID2D1GradientStopCollection *gradient, ID2D1RadialGradientBrush **brush)
 243 {
 244     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 245
 246     TRACE("iface %p, gradient_brush_desc %p, brush_desc %p, gradient %p, brush %p.\n",
 247             iface, gradient_brush_desc, brush_desc, gradient, brush);
 248
 249     return ID2D1RenderTarget_CreateRadialGradientBrush(render_target->dxgi_target,
 250             gradient_brush_desc, brush_desc, gradient, brush);
 251 }
 252
 253 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateCompatibleRenderTarget(ID2D1RenderTarget *iface,
 254         const D2D1_SIZE_F *size, const D2D1_SIZE_U *pixel_size, const D2D1_PIXEL_FORMAT *format,
 255         D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS options, ID2D1BitmapRenderTarget **render_target)
 256 {
 257     struct d2d_wic_render_target *rt = impl_from_ID2D1RenderTarget(iface);
 258
 259     TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p,\n",
 260             iface, size, pixel_size, format, options, render_target);
 261
 262     return ID2D1RenderTarget_CreateCompatibleRenderTarget(rt->dxgi_target,
 263             size, pixel_size, format, options, render_target);
 264 }
 265
 266 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateLayer(ID2D1RenderTarget *iface,
 267         const D2D1_SIZE_F *size, ID2D1Layer **layer)
 268 {
 269     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 270
 271     TRACE("iface %p, size %p, layer %p.\n", iface, size, layer);
 272
 273     return ID2D1RenderTarget_CreateLayer(render_target->dxgi_target, size, layer);
 274 }
 275
 276 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_CreateMesh(ID2D1RenderTarget *iface, ID2D1Mesh **mesh)
 277 {
 278     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 279
 280     TRACE("iface %p, mesh %p.\n", iface, mesh);
 281
 282     return ID2D1RenderTarget_CreateMesh(render_target->dxgi_target, mesh);
 283 }
 284
 285 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawLine(ID2D1RenderTarget *iface,
 286         D2D1_POINT_2F p0, D2D1_POINT_2F p1, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 287 {
 288     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 289
 290     TRACE("iface %p, p0 {%.8e, %.8e}, p1 {%.8e, %.8e}, brush %p, stroke_width %.8e, stroke_style %p.\n",
 291             iface, p0.x, p0.y, p1.x, p1.y, brush, stroke_width, stroke_style);
 292
 293     ID2D1RenderTarget_DrawLine(render_target->dxgi_target, p0, p1, brush, stroke_width, stroke_style);
 294 }
 295
 296 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawRectangle(ID2D1RenderTarget *iface,
 297         const D2D1_RECT_F *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 298 {
 299     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 300
 301     TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 302             iface, rect, brush, stroke_width, stroke_style);
 303
 304     ID2D1RenderTarget_DrawRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style);
 305 }
 306
 307 static void STDMETHODCALLTYPE d2d_wic_render_target_FillRectangle(ID2D1RenderTarget *iface,
 308         const D2D1_RECT_F *rect, ID2D1Brush *brush)
 309 {
 310     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 311
 312     TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush);
 313
 314     ID2D1RenderTarget_FillRectangle(render_target->dxgi_target, rect, brush);
 315 }
 316
 317 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawRoundedRectangle(ID2D1RenderTarget *iface,
 318         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 319 {
 320     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 321
 322     TRACE("iface %p, rect %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 323             iface, rect, brush, stroke_width, stroke_style);
 324
 325     ID2D1RenderTarget_DrawRoundedRectangle(render_target->dxgi_target, rect, brush, stroke_width, stroke_style);
 326 }
 327
 328 static void STDMETHODCALLTYPE d2d_wic_render_target_FillRoundedRectangle(ID2D1RenderTarget *iface,
 329         const D2D1_ROUNDED_RECT *rect, ID2D1Brush *brush)
 330 {
 331     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 332
 333     TRACE("iface %p, rect %p, brush %p.\n", iface, rect, brush);
 334
 335     ID2D1RenderTarget_FillRoundedRectangle(render_target->dxgi_target, rect, brush);
 336 }
 337
 338 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawEllipse(ID2D1RenderTarget *iface,
 339         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 340 {
 341     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 342
 343     TRACE("iface %p, ellipse %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 344             iface, ellipse, brush, stroke_width, stroke_style);
 345
 346     ID2D1RenderTarget_DrawEllipse(render_target->dxgi_target, ellipse, brush, stroke_width, stroke_style);
 347 }
 348
 349 static void STDMETHODCALLTYPE d2d_wic_render_target_FillEllipse(ID2D1RenderTarget *iface,
 350         const D2D1_ELLIPSE *ellipse, ID2D1Brush *brush)
 351 {
 352     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 353
 354     TRACE("iface %p, ellipse %p, brush %p.\n", iface, ellipse, brush);
 355
 356     ID2D1RenderTarget_FillEllipse(render_target->dxgi_target, ellipse, brush);
 357 }
 358
 359 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawGeometry(ID2D1RenderTarget *iface,
 360         ID2D1Geometry *geometry, ID2D1Brush *brush, float stroke_width, ID2D1StrokeStyle *stroke_style)
 361 {
 362     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 363
 364     TRACE("iface %p, geometry %p, brush %p, stroke_width %.8e, stroke_style %p.\n",
 365             iface, geometry, brush, stroke_width, stroke_style);
 366
 367     ID2D1RenderTarget_DrawGeometry(render_target->dxgi_target, geometry, brush, stroke_width, stroke_style);
 368 }
 369
 370 static void STDMETHODCALLTYPE d2d_wic_render_target_FillGeometry(ID2D1RenderTarget *iface,
 371         ID2D1Geometry *geometry, ID2D1Brush *brush, ID2D1Brush *opacity_brush)
 372 {
 373     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 374
 375     TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush);
 376
 377     ID2D1RenderTarget_FillGeometry(render_target->dxgi_target, geometry, brush, opacity_brush);
 378 }
 379
 380 static void STDMETHODCALLTYPE d2d_wic_render_target_FillMesh(ID2D1RenderTarget *iface,
 381         ID2D1Mesh *mesh, ID2D1Brush *brush)
 382 {
 383     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 384
 385     TRACE("iface %p, mesh %p, brush %p.\n", iface, mesh, brush);
 386
 387     ID2D1RenderTarget_FillMesh(render_target->dxgi_target, mesh, brush);
 388 }
 389
 390 static void STDMETHODCALLTYPE d2d_wic_render_target_FillOpacityMask(ID2D1RenderTarget *iface,
 391         ID2D1Bitmap *mask, ID2D1Brush *brush, D2D1_OPACITY_MASK_CONTENT content,
 392         const D2D1_RECT_F *dst_rect, const D2D1_RECT_F *src_rect)
 393 {
 394     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 395
 396     TRACE("iface %p, mask %p, brush %p, content %#x, dst_rect %p, src_rect %p.\n",
 397             iface, mask, brush, content, dst_rect, src_rect);
 398
 399     ID2D1RenderTarget_FillOpacityMask(render_target->dxgi_target,
 400             mask, brush, content, dst_rect, src_rect);
 401 }
 402
 403 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawBitmap(ID2D1RenderTarget *iface,
 404         ID2D1Bitmap *bitmap, const D2D1_RECT_F *dst_rect, float opacity,
 405         D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode, const D2D1_RECT_F *src_rect)
 406 {
 407     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 408
 409     TRACE("iface %p, bitmap %p, dst_rect %p, opacity %.8e, interpolation_mode %#x, src_rect %p.\n",
 410             iface, bitmap, dst_rect, opacity, interpolation_mode, src_rect);
 411
 412     ID2D1RenderTarget_DrawBitmap(render_target->dxgi_target,
 413             bitmap, dst_rect, opacity, interpolation_mode, src_rect);
 414 }
 415
 416 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawText(ID2D1RenderTarget *iface,
 417         const WCHAR *string, UINT32 string_len, IDWriteTextFormat *text_format, const D2D1_RECT_F *layout_rect,
 418         ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options, DWRITE_MEASURING_MODE measuring_mode)
 419 {
 420     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 421
 422     TRACE("iface %p, string %s, string_len %u, text_format %p, layout_rect %p, "
 423             "brush %p, options %#x, measuring_mode %#x.\n",
 424             iface, debugstr_wn(string, string_len), string_len, text_format, layout_rect,
 425             brush, options, measuring_mode);
 426
 427     ID2D1RenderTarget_DrawText(render_target->dxgi_target, string, string_len,
 428             text_format, layout_rect, brush, options, measuring_mode);
 429 }
 430
 431 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawTextLayout(ID2D1RenderTarget *iface,
 432         D2D1_POINT_2F origin, IDWriteTextLayout *layout, ID2D1Brush *brush, D2D1_DRAW_TEXT_OPTIONS options)
 433 {
 434     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 435
 436     TRACE("iface %p, origin {%.8e, %.8e}, layout %p, brush %p, options %#x.\n",
 437             iface, origin.x, origin.y, layout, brush, options);
 438
 439     ID2D1RenderTarget_DrawTextLayout(render_target->dxgi_target, origin, layout, brush, options);
 440 }
 441
 442 static void STDMETHODCALLTYPE d2d_wic_render_target_DrawGlyphRun(ID2D1RenderTarget *iface,
 443         D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush,
 444         DWRITE_MEASURING_MODE measuring_mode)
 445 {
 446     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 447
 448     TRACE("iface %p, baseline_origin {%.8e, %.8e}, glyph_run %p, brush %p, measuring_mode %#x.\n",
 449             iface, baseline_origin.x, baseline_origin.y, glyph_run, brush, measuring_mode);
 450
 451     ID2D1RenderTarget_DrawGlyphRun(render_target->dxgi_target,
 452             baseline_origin, glyph_run, brush, measuring_mode);
 453 }
 454
 455 static void STDMETHODCALLTYPE d2d_wic_render_target_SetTransform(ID2D1RenderTarget *iface,
 456         const D2D1_MATRIX_3X2_F *transform)
 457 {
 458     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 459
 460     TRACE("iface %p, transform %p.\n", iface, transform);
 461
 462     ID2D1RenderTarget_SetTransform(render_target->dxgi_target, transform);
 463 }
 464
 465 static void STDMETHODCALLTYPE d2d_wic_render_target_GetTransform(ID2D1RenderTarget *iface,
 466         D2D1_MATRIX_3X2_F *transform)
 467 {
 468     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 469
 470     TRACE("iface %p, transform %p.\n", iface, transform);
 471
 472     ID2D1RenderTarget_GetTransform(render_target->dxgi_target, transform);
 473 }
 474
 475 static void STDMETHODCALLTYPE d2d_wic_render_target_SetAntialiasMode(ID2D1RenderTarget *iface,
 476         D2D1_ANTIALIAS_MODE antialias_mode)
 477 {
 478     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 479
 480     TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode);
 481
 482     ID2D1RenderTarget_SetAntialiasMode(render_target->dxgi_target, antialias_mode);
 483 }
 484
 485 static D2D1_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_wic_render_target_GetAntialiasMode(ID2D1RenderTarget *iface)
 486 {
 487     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 488
 489     TRACE("iface %p.\n", iface);
 490
 491     return ID2D1RenderTarget_GetAntialiasMode(render_target->dxgi_target);
 492 }
 493
 494 static void STDMETHODCALLTYPE d2d_wic_render_target_SetTextAntialiasMode(ID2D1RenderTarget *iface,
 495         D2D1_TEXT_ANTIALIAS_MODE antialias_mode)
 496 {
 497     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 498
 499     TRACE("iface %p, antialias_mode %#x.\n", iface, antialias_mode);
 500
 501     ID2D1RenderTarget_SetTextAntialiasMode(render_target->dxgi_target, antialias_mode);
 502 }
 503
 504 static D2D1_TEXT_ANTIALIAS_MODE STDMETHODCALLTYPE d2d_wic_render_target_GetTextAntialiasMode(ID2D1RenderTarget *iface)
 505 {
 506     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 507
 508     TRACE("iface %p.\n", iface);
 509
 510     return ID2D1RenderTarget_GetTextAntialiasMode(render_target->dxgi_target);
 511 }
 512
 513 static void STDMETHODCALLTYPE d2d_wic_render_target_SetTextRenderingParams(ID2D1RenderTarget *iface,
 514         IDWriteRenderingParams *text_rendering_params)
 515 {
 516     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 517
 518     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
 519
 520     ID2D1RenderTarget_SetTextRenderingParams(render_target->dxgi_target, text_rendering_params);
 521 }
 522
 523 static void STDMETHODCALLTYPE d2d_wic_render_target_GetTextRenderingParams(ID2D1RenderTarget *iface,
 524         IDWriteRenderingParams **text_rendering_params)
 525 {
 526     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 527
 528     TRACE("iface %p, text_rendering_params %p.\n", iface, text_rendering_params);
 529
 530     ID2D1RenderTarget_GetTextRenderingParams(render_target->dxgi_target, text_rendering_params);
 531 }
 532
 533 static void STDMETHODCALLTYPE d2d_wic_render_target_SetTags(ID2D1RenderTarget *iface, D2D1_TAG tag1, D2D1_TAG tag2)
 534 {
 535     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 536
 537     TRACE("iface %p, tag1 %s, tag2 %s.\n", iface, wine_dbgstr_longlong(tag1), wine_dbgstr_longlong(tag2));
 538
 539     ID2D1RenderTarget_SetTags(render_target->dxgi_target, tag1, tag2);
 540 }
 541
 542 static void STDMETHODCALLTYPE d2d_wic_render_target_GetTags(ID2D1RenderTarget *iface, D2D1_TAG *tag1, D2D1_TAG *tag2)
 543 {
 544     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 545
 546     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 547
 548     ID2D1RenderTarget_GetTags(render_target->dxgi_target, tag1, tag2);
 549 }
 550
 551 static void STDMETHODCALLTYPE d2d_wic_render_target_PushLayer(ID2D1RenderTarget *iface,
 552         const D2D1_LAYER_PARAMETERS *layer_parameters, ID2D1Layer *layer)
 553 {
 554     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 555
 556     TRACE("iface %p, layer_parameters %p, layer %p.\n", iface, layer_parameters, layer);
 557
 558     ID2D1RenderTarget_PushLayer(render_target->dxgi_target, layer_parameters, layer);
 559 }
 560
 561 static void STDMETHODCALLTYPE d2d_wic_render_target_PopLayer(ID2D1RenderTarget *iface)
 562 {
 563     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 564
 565     TRACE("iface %p.\n", iface);
 566
 567     ID2D1RenderTarget_PopLayer(render_target->dxgi_target);
 568 }
 569
 570 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_Flush(ID2D1RenderTarget *iface, D2D1_TAG *tag1, D2D1_TAG *tag2)
 571 {
 572     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 573     HRESULT hr;
 574
 575     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 576
 577     hr = ID2D1RenderTarget_Flush(render_target->dxgi_target, tag1, tag2);
 578     sync_bitmap(render_target);
 579
 580     return hr;
 581 }
 582
 583 static void STDMETHODCALLTYPE d2d_wic_render_target_SaveDrawingState(ID2D1RenderTarget *iface,
 584         ID2D1DrawingStateBlock *state_block)
 585 {
 586     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 587
 588     TRACE("iface %p, state_block %p.\n", iface, state_block);
 589
 590     ID2D1RenderTarget_SaveDrawingState(render_target->dxgi_target, state_block);
 591 }
 592
 593 static void STDMETHODCALLTYPE d2d_wic_render_target_RestoreDrawingState(ID2D1RenderTarget *iface,
 594         ID2D1DrawingStateBlock *state_block)
 595 {
 596     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 597
 598     TRACE("iface %p, state_block %p.\n", iface, state_block);
 599
 600     ID2D1RenderTarget_RestoreDrawingState(render_target->dxgi_target, state_block);
 601 }
 602
 603 static void STDMETHODCALLTYPE d2d_wic_render_target_PushAxisAlignedClip(ID2D1RenderTarget *iface,
 604         const D2D1_RECT_F *clip_rect, D2D1_ANTIALIAS_MODE antialias_mode)
 605 {
 606     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 607
 608     TRACE("iface %p, clip_rect %p, antialias_mode %#x.\n", iface, clip_rect, antialias_mode);
 609
 610     ID2D1RenderTarget_PushAxisAlignedClip(render_target->dxgi_target, clip_rect, antialias_mode);
 611 }
 612
 613 static void STDMETHODCALLTYPE d2d_wic_render_target_PopAxisAlignedClip(ID2D1RenderTarget *iface)
 614 {
 615     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 616
 617     TRACE("iface %p.\n", iface);
 618
 619     ID2D1RenderTarget_PopAxisAlignedClip(render_target->dxgi_target);
 620 }
 621
 622 static void STDMETHODCALLTYPE d2d_wic_render_target_Clear(ID2D1RenderTarget *iface, const D2D1_COLOR_F *color)
 623 {
 624     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 625
 626     TRACE("iface %p, color %p.\n", iface, color);
 627
 628     ID2D1RenderTarget_Clear(render_target->dxgi_target, color);
 629 }
 630
 631 static void STDMETHODCALLTYPE d2d_wic_render_target_BeginDraw(ID2D1RenderTarget *iface)
 632 {
 633     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 634
 635     TRACE("iface %p.\n", iface);
 636
 637     ID2D1RenderTarget_BeginDraw(render_target->dxgi_target);
 638 }
 639
 640 static HRESULT STDMETHODCALLTYPE d2d_wic_render_target_EndDraw(ID2D1RenderTarget *iface,
 641         D2D1_TAG *tag1, D2D1_TAG *tag2)
 642 {
 643     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 644     HRESULT hr;
 645
 646     TRACE("iface %p, tag1 %p, tag2 %p.\n", iface, tag1, tag2);
 647
 648     hr = ID2D1RenderTarget_EndDraw(render_target->dxgi_target, tag1, tag2);
 649     sync_bitmap(render_target);
 650
 651     return hr;
 652 }
 653
 654 static D2D1_PIXEL_FORMAT * STDMETHODCALLTYPE d2d_wic_render_target_GetPixelFormat(ID2D1RenderTarget *iface,
 655         D2D1_PIXEL_FORMAT *format)
 656 {
 657     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 658
 659     TRACE("iface %p, format %p.\n", iface, format);
 660
 661     *format = ID2D1RenderTarget_GetPixelFormat(render_target->dxgi_target);
 662     return format;
 663 }
 664
 665 static void STDMETHODCALLTYPE d2d_wic_render_target_SetDpi(ID2D1RenderTarget *iface, float dpi_x, float dpi_y)
 666 {
 667     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 668
 669     TRACE("iface %p, dpi_x %.8e, dpi_y %.8e.\n", iface, dpi_x, dpi_y);
 670
 671     ID2D1RenderTarget_SetDpi(render_target->dxgi_target, dpi_x, dpi_y);
 672 }
 673
 674 static void STDMETHODCALLTYPE d2d_wic_render_target_GetDpi(ID2D1RenderTarget *iface, float *dpi_x, float *dpi_y)
 675 {
 676     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 677
 678     TRACE("iface %p, dpi_x %p, dpi_y %p.\n", iface, dpi_x, dpi_y);
 679
 680     ID2D1RenderTarget_GetDpi(render_target->dxgi_target, dpi_x, dpi_y);
 681 }
 682
 683 static D2D1_SIZE_F * STDMETHODCALLTYPE d2d_wic_render_target_GetSize(ID2D1RenderTarget *iface, D2D1_SIZE_F *size)
 684 {
 685     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 686
 687     TRACE("iface %p, size %p.\n", iface, size);
 688
 689     *size = ID2D1RenderTarget_GetSize(render_target->dxgi_target);
 690     return size;
 691 }
 692
 693 static D2D1_SIZE_U * STDMETHODCALLTYPE d2d_wic_render_target_GetPixelSize(ID2D1RenderTarget *iface,
 694         D2D1_SIZE_U *pixel_size)
 695 {
 696     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 697
 698     TRACE("iface %p, pixel_size %p.\n", iface, pixel_size);
 699
 700     *pixel_size = ID2D1RenderTarget_GetPixelSize(render_target->dxgi_target);
 701     return pixel_size;
 702 }
 703
 704 static UINT32 STDMETHODCALLTYPE d2d_wic_render_target_GetMaximumBitmapSize(ID2D1RenderTarget *iface)
 705 {
 706     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 707
 708     TRACE("iface %p.\n", iface);
 709
 710     return ID2D1RenderTarget_GetMaximumBitmapSize(render_target->dxgi_target);
 711 }
 712
 713 static BOOL STDMETHODCALLTYPE d2d_wic_render_target_IsSupported(ID2D1RenderTarget *iface,
 714         const D2D1_RENDER_TARGET_PROPERTIES *desc)
 715 {
 716     struct d2d_wic_render_target *render_target = impl_from_ID2D1RenderTarget(iface);
 717
 718     TRACE("iface %p, desc %p.\n", iface, desc);
 719
 720     return ID2D1RenderTarget_IsSupported(render_target->dxgi_target, desc);
 721 }
 722
 723 static const struct ID2D1RenderTargetVtbl d2d_wic_render_target_vtbl =
 724 {
 725     d2d_wic_render_target_QueryInterface,
 726     d2d_wic_render_target_AddRef,
 727     d2d_wic_render_target_Release,
 728     d2d_wic_render_target_GetFactory,
 729     d2d_wic_render_target_CreateBitmap,
 730     d2d_wic_render_target_CreateBitmapFromWicBitmap,
 731     d2d_wic_render_target_CreateSharedBitmap,
 732     d2d_wic_render_target_CreateBitmapBrush,
 733     d2d_wic_render_target_CreateSolidColorBrush,
 734     d2d_wic_render_target_CreateGradientStopCollection,
 735     d2d_wic_render_target_CreateLinearGradientBrush,
 736     d2d_wic_render_target_CreateRadialGradientBrush,
 737     d2d_wic_render_target_CreateCompatibleRenderTarget,
 738     d2d_wic_render_target_CreateLayer,
 739     d2d_wic_render_target_CreateMesh,
 740     d2d_wic_render_target_DrawLine,
 741     d2d_wic_render_target_DrawRectangle,
 742     d2d_wic_render_target_FillRectangle,
 743     d2d_wic_render_target_DrawRoundedRectangle,
 744     d2d_wic_render_target_FillRoundedRectangle,
 745     d2d_wic_render_target_DrawEllipse,
 746     d2d_wic_render_target_FillEllipse,
 747     d2d_wic_render_target_DrawGeometry,
 748     d2d_wic_render_target_FillGeometry,
 749     d2d_wic_render_target_FillMesh,
 750     d2d_wic_render_target_FillOpacityMask,
 751     d2d_wic_render_target_DrawBitmap,
 752     d2d_wic_render_target_DrawText,
 753     d2d_wic_render_target_DrawTextLayout,
 754     d2d_wic_render_target_DrawGlyphRun,
 755     d2d_wic_render_target_SetTransform,
 756     d2d_wic_render_target_GetTransform,
 757     d2d_wic_render_target_SetAntialiasMode,
 758     d2d_wic_render_target_GetAntialiasMode,
 759     d2d_wic_render_target_SetTextAntialiasMode,
 760     d2d_wic_render_target_GetTextAntialiasMode,
 761     d2d_wic_render_target_SetTextRenderingParams,
 762     d2d_wic_render_target_GetTextRenderingParams,
 763     d2d_wic_render_target_SetTags,
 764     d2d_wic_render_target_GetTags,
 765     d2d_wic_render_target_PushLayer,
 766     d2d_wic_render_target_PopLayer,
 767     d2d_wic_render_target_Flush,
 768     d2d_wic_render_target_SaveDrawingState,
 769     d2d_wic_render_target_RestoreDrawingState,
 770     d2d_wic_render_target_PushAxisAlignedClip,
 771     d2d_wic_render_target_PopAxisAlignedClip,
 772     d2d_wic_render_target_Clear,
 773     d2d_wic_render_target_BeginDraw,
 774     d2d_wic_render_target_EndDraw,
 775     d2d_wic_render_target_GetPixelFormat,
 776     d2d_wic_render_target_SetDpi,
 777     d2d_wic_render_target_GetDpi,
 778     d2d_wic_render_target_GetSize,
 779     d2d_wic_render_target_GetPixelSize,
 780     d2d_wic_render_target_GetMaximumBitmapSize,
 781     d2d_wic_render_target_IsSupported,
 782 };
 783
 784 HRESULT d2d_wic_render_target_init(struct d2d_wic_render_target *render_target, ID2D1Factory *factory,
 785         IWICBitmap *bitmap, const D2D1_RENDER_TARGET_PROPERTIES *desc)
 786 {
 787     D3D10_TEXTURE2D_DESC texture_desc;
 788     ID3D10Texture2D *texture;
 789     ID3D10Device1 *device;
 790     HRESULT hr;
 791
 792     FIXME("Ignoring render target properties.\n");
 793
 794     render_target->ID2D1RenderTarget_iface.lpVtbl = &d2d_wic_render_target_vtbl;
 795     render_target->refcount = 1;
 796
 797     if (FAILED(hr = IWICBitmap_GetSize(bitmap, &render_target->width, &render_target->height)))
 798     {
 799         WARN("Failed to get bitmap dimensions, hr %#x.\n", hr);
 800         return hr;
 801     }
 802
 803     texture_desc.Width = render_target->width;
 804     texture_desc.Height = render_target->height;
 805     texture_desc.MipLevels = 1;
 806     texture_desc.ArraySize = 1;
 807
 808     texture_desc.Format = desc->pixelFormat.format;
 809     if (texture_desc.Format == DXGI_FORMAT_UNKNOWN)
 810     {
 811         WICPixelFormatGUID bitmap_format;
 812
 813         if (FAILED(hr = IWICBitmap_GetPixelFormat(bitmap, &bitmap_format)))
 814         {
 815             WARN("Failed to get bitmap format, hr %#x.\n", hr);
 816             return hr;
 817         }
 818
 819         if (IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppPBGRA)
 820                 || IsEqualGUID(&bitmap_format, &GUID_WICPixelFormat32bppBGR))
 821         {
 822             texture_desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
 823         }
 824         else
 825         {
 826             WARN("Unsupported WIC bitmap format %s.\n", debugstr_guid(&bitmap_format));
 827             return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 828         }
 829     }
 830
 831     switch (texture_desc.Format)
 832     {
 833         case DXGI_FORMAT_B8G8R8A8_UNORM:
 834             render_target->bpp = 4;
 835             break;
 836
 837         default:
 838             FIXME("Unhandled format %#x.\n", texture_desc.Format);
 839             return D2DERR_UNSUPPORTED_PIXEL_FORMAT;
 840     }
 841
 842     texture_desc.SampleDesc.Count = 1;
 843     texture_desc.SampleDesc.Quality = 0;
 844     texture_desc.Usage = D3D10_USAGE_DEFAULT;
 845     texture_desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
 846     texture_desc.CPUAccessFlags = 0;
 847     texture_desc.MiscFlags = 0;
 848
 849     if (FAILED(hr = D3D10CreateDevice1(NULL, D3D10_DRIVER_TYPE_HARDWARE, NULL,
 850             D3D10_CREATE_DEVICE_BGRA_SUPPORT, D3D10_FEATURE_LEVEL_10_0, D3D10_1_SDK_VERSION, &device)))
 851     {
 852         WARN("Failed to create device, hr %#x.\n", hr);
 853         return hr;
 854     }
 855
 856     if (FAILED(hr = ID3D10Device1_CreateTexture2D(device, &texture_desc, NULL, &texture)))
 857     {
 858         WARN("Failed to create texture, hr %#x.\n", hr);
 859         ID3D10Device1_Release(device);
 860         return hr;
 861     }
 862
 863     hr = ID3D10Texture2D_QueryInterface(texture, &IID_IDXGISurface, (void **)&render_target->dxgi_surface);
 864     ID3D10Texture2D_Release(texture);
 865     if (FAILED(hr))
 866     {
 867         WARN("Failed to get DXGI surface interface, hr %#x.\n", hr);
 868         ID3D10Device1_Release(device);
 869         return hr;
 870     }
 871
 872     texture_desc.Usage = D3D10_USAGE_STAGING;
 873     texture_desc.BindFlags = 0;
 874     texture_desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
 875
 876     hr = ID3D10Device1_CreateTexture2D(device, &texture_desc, NULL, &render_target->readback_texture);
 877     ID3D10Device1_Release(device);
 878     if (FAILED(hr))
 879     {
 880         WARN("Failed to create readback texture, hr %#x.\n", hr);
 881         IDXGISurface_Release(render_target->dxgi_surface);
 882         return hr;
 883     }
 884
 885     if (FAILED(hr = ID2D1Factory_CreateDxgiSurfaceRenderTarget(factory,
 886             render_target->dxgi_surface, desc, &render_target->dxgi_target)))
 887     {
 888         WARN("Failed to create DXGI surface render target, hr %#x.\n", hr);
 889         ID3D10Texture2D_Release(render_target->readback_texture);
 890         IDXGISurface_Release(render_target->dxgi_surface);
 891         return hr;
 892     }
 893
 894     render_target->bitmap = bitmap;
 895     IWICBitmap_AddRef(bitmap);
 896
 897     return S_OK;
 898 }