dlls/dxgi/swapchain.c

   1 /*
   2  * Copyright 2008 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
  20 #include "dxgi_private.h"
  21
  22 #define VKD3D_NO_VULKAN_H
  23 #define VKD3D_NO_WIN32_TYPES
  24 #include "wine/vulkan.h"
  25 #include <vkd3d.h>
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(dxgi);
  28 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  29
  30 static DXGI_SWAP_EFFECT dxgi_swap_effect_from_wined3d(enum wined3d_swap_effect swap_effect)
  31 {
  32     switch (swap_effect)
  33     {
  34         case WINED3D_SWAP_EFFECT_DISCARD:
  35             return DXGI_SWAP_EFFECT_DISCARD;
  36         case WINED3D_SWAP_EFFECT_SEQUENTIAL:
  37             return DXGI_SWAP_EFFECT_SEQUENTIAL;
  38         case WINED3D_SWAP_EFFECT_FLIP_DISCARD:
  39             return DXGI_SWAP_EFFECT_FLIP_DISCARD;
  40         case WINED3D_SWAP_EFFECT_FLIP_SEQUENTIAL:
  41             return DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
  42         default:
  43             FIXME("Invalid swap effect %#x.\n", swap_effect);
  44             return DXGI_SWAP_EFFECT_DISCARD;
  45     }
  46 }
  47
  48 static BOOL dxgi_validate_flip_swap_effect_format(DXGI_FORMAT format)
  49 {
  50     switch (format)
  51     {
  52         case DXGI_FORMAT_R16G16B16A16_FLOAT:
  53         case DXGI_FORMAT_R10G10B10A2_UNORM:
  54         case DXGI_FORMAT_R8G8B8A8_UNORM:
  55         case DXGI_FORMAT_B8G8R8A8_UNORM:
  56             return TRUE;
  57         default:
  58             WARN("Invalid swapchain format %#x for flip presentation model.\n", format);
  59             return FALSE;
  60     }
  61 }
  62
  63 BOOL dxgi_validate_swapchain_desc(const DXGI_SWAP_CHAIN_DESC1 *desc)
  64 {
  65     unsigned int min_buffer_count;
  66
  67     switch (desc->SwapEffect)
  68     {
  69         case DXGI_SWAP_EFFECT_DISCARD:
  70         case DXGI_SWAP_EFFECT_SEQUENTIAL:
  71             min_buffer_count = 1;
  72             break;
  73
  74         case DXGI_SWAP_EFFECT_FLIP_DISCARD:
  75         case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL:
  76             min_buffer_count = 2;
  77
  78             if (desc->Format && !dxgi_validate_flip_swap_effect_format(desc->Format))
  79                 return FALSE;
  80
  81             if (desc->SampleDesc.Count != 1 || desc->SampleDesc.Quality)
  82             {
  83                 WARN("Invalid sample desc %u, %u for swap effect %#x.\n",
  84                         desc->SampleDesc.Count, desc->SampleDesc.Quality, desc->SwapEffect);
  85                 return FALSE;
  86             }
  87             break;
  88
  89         default:
  90             WARN("Invalid swap effect %u used.\n", desc->SwapEffect);
  91             return FALSE;
  92     }
  93
  94     if (desc->BufferCount < min_buffer_count || desc->BufferCount > DXGI_MAX_SWAP_CHAIN_BUFFERS)
  95     {
  96         WARN("BufferCount is %u.\n", desc->BufferCount);
  97         return FALSE;
  98     }
  99
 100     return TRUE;
 101 }
 102
 103 HRESULT dxgi_get_output_from_window(IWineDXGIFactory *factory, HWND window, IDXGIOutput **dxgi_output)
 104 {
 105     unsigned int adapter_idx, output_idx;
 106     DXGI_OUTPUT_DESC desc;
 107     IDXGIAdapter *adapter;
 108     IDXGIOutput *output;
 109     HMONITOR monitor;
 110     HRESULT hr;
 111
 112     if (!(monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST)))
 113     {
 114         WARN("Failed to get monitor from window.\n");
 115         return DXGI_ERROR_INVALID_CALL;
 116     }
 117
 118     for (adapter_idx = 0; SUCCEEDED(hr = IWineDXGIFactory_EnumAdapters(factory, adapter_idx, &adapter));
 119             ++adapter_idx)
 120     {
 121         for (output_idx = 0; SUCCEEDED(hr = IDXGIAdapter_EnumOutputs(adapter, output_idx,
 122                 &output)); ++output_idx)
 123         {
 124             if (FAILED(hr = IDXGIOutput_GetDesc(output, &desc)))
 125             {
 126                 WARN("Adapter %u output %u: Failed to get output desc, hr %#lx.\n", adapter_idx,
 127                         output_idx, hr);
 128                 IDXGIOutput_Release(output);
 129                 continue;
 130             }
 131
 132             if (desc.Monitor == monitor)
 133             {
 134                 *dxgi_output = output;
 135                 IDXGIAdapter_Release(adapter);
 136                 return S_OK;
 137             }
 138
 139             IDXGIOutput_Release(output);
 140         }
 141         IDXGIAdapter_Release(adapter);
 142     }
 143
 144     if (hr != DXGI_ERROR_NOT_FOUND)
 145         WARN("Failed to enumerate outputs, hr %#lx.\n", hr);
 146
 147     WARN("Output could not be found.\n");
 148     return DXGI_ERROR_NOT_FOUND;
 149 }
 150
 151 static HRESULT dxgi_swapchain_resize_target(struct wined3d_swapchain_state *state,
 152         const DXGI_MODE_DESC *target_mode_desc)
 153 {
 154     struct wined3d_display_mode mode;
 155
 156     if (!target_mode_desc)
 157     {
 158         WARN("Invalid pointer.\n");
 159         return DXGI_ERROR_INVALID_CALL;
 160     }
 161
 162     TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc));
 163
 164     if (target_mode_desc->Scaling)
 165         FIXME("Ignoring scaling %#x.\n", target_mode_desc->Scaling);
 166
 167     wined3d_display_mode_from_dxgi(&mode, target_mode_desc);
 168
 169     return wined3d_swapchain_state_resize_target(state, &mode);
 170 }
 171
 172 static HWND d3d11_swapchain_get_hwnd(struct d3d11_swapchain *swapchain)
 173 {
 174     struct wined3d_swapchain_desc wined3d_desc;
 175
 176     wined3d_mutex_lock();
 177     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 178     wined3d_mutex_unlock();
 179
 180     return wined3d_desc.device_window;
 181 }
 182
 183 static inline struct d3d11_swapchain *d3d11_swapchain_from_IDXGISwapChain2(IDXGISwapChain2 *iface)
 184 {
 185     return CONTAINING_RECORD(iface, struct d3d11_swapchain, IDXGISwapChain2_iface);
 186 }
 187
 188 /* IUnknown methods */
 189
 190 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_QueryInterface(IDXGISwapChain2 *iface, REFIID riid, void **object)
 191 {
 192     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 193
 194     if (IsEqualGUID(riid, &IID_IUnknown)
 195             || IsEqualGUID(riid, &IID_IDXGIObject)
 196             || IsEqualGUID(riid, &IID_IDXGIDeviceSubObject)
 197             || IsEqualGUID(riid, &IID_IDXGISwapChain)
 198             || IsEqualGUID(riid, &IID_IDXGISwapChain1)
 199             || IsEqualGUID(riid, &IID_IDXGISwapChain2))
 200     {
 201         IUnknown_AddRef(iface);
 202         *object = iface;
 203         return S_OK;
 204     }
 205
 206     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 207
 208     *object = NULL;
 209     return E_NOINTERFACE;
 210 }
 211
 212 static ULONG STDMETHODCALLTYPE d3d11_swapchain_AddRef(IDXGISwapChain2 *iface)
 213 {
 214     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 215     ULONG refcount = InterlockedIncrement(&swapchain->refcount);
 216
 217     TRACE("%p increasing refcount to %lu.\n", swapchain, refcount);
 218
 219     if (refcount == 1)
 220         wined3d_swapchain_incref(swapchain->wined3d_swapchain);
 221
 222     return refcount;
 223 }
 224
 225 static ULONG STDMETHODCALLTYPE d3d11_swapchain_Release(IDXGISwapChain2 *iface)
 226 {
 227     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 228     ULONG refcount = InterlockedDecrement(&swapchain->refcount);
 229
 230     TRACE("%p decreasing refcount to %lu.\n", swapchain, refcount);
 231
 232     if (!refcount)
 233     {
 234         IWineDXGIDevice *device = swapchain->device;
 235         if (swapchain->target)
 236         {
 237             WARN("Releasing fullscreen swapchain.\n");
 238             IDXGIOutput_Release(swapchain->target);
 239         }
 240         IWineDXGIFactory_Release(swapchain->factory);
 241         wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 242         IWineDXGIDevice_Release(device);
 243     }
 244
 245     return refcount;
 246 }
 247
 248 /* IDXGIObject methods */
 249
 250 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetPrivateData(IDXGISwapChain2 *iface,
 251         REFGUID guid, UINT data_size, const void *data)
 252 {
 253     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 254
 255     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 256
 257     return dxgi_set_private_data(&swapchain->private_store, guid, data_size, data);
 258 }
 259
 260 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetPrivateDataInterface(IDXGISwapChain2 *iface,
 261         REFGUID guid, const IUnknown *object)
 262 {
 263     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 264
 265     TRACE("iface %p, guid %s, object %p.\n", iface, debugstr_guid(guid), object);
 266
 267     return dxgi_set_private_data_interface(&swapchain->private_store, guid, object);
 268 }
 269
 270 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetPrivateData(IDXGISwapChain2 *iface,
 271         REFGUID guid, UINT *data_size, void *data)
 272 {
 273     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 274
 275     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 276
 277     return dxgi_get_private_data(&swapchain->private_store, guid, data_size, data);
 278 }
 279
 280 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetParent(IDXGISwapChain2 *iface, REFIID riid, void **parent)
 281 {
 282     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 283
 284     TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent);
 285
 286     return IWineDXGIFactory_QueryInterface(swapchain->factory, riid, parent);
 287 }
 288
 289 /* IDXGIDeviceSubObject methods */
 290
 291 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDevice(IDXGISwapChain2 *iface, REFIID riid, void **device)
 292 {
 293     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 294
 295     TRACE("iface %p, riid %s, device %p.\n", iface, debugstr_guid(riid), device);
 296
 297     return IWineDXGIDevice_QueryInterface(swapchain->device, riid, device);
 298 }
 299
 300 /* IDXGISwapChain1 methods */
 301
 302 static HRESULT d3d11_swapchain_present(struct d3d11_swapchain *swapchain,
 303         unsigned int sync_interval, unsigned int flags)
 304 {
 305     HRESULT hr;
 306
 307     if (sync_interval > 4)
 308     {
 309         WARN("Invalid sync interval %u.\n", sync_interval);
 310         return DXGI_ERROR_INVALID_CALL;
 311     }
 312
 313     if (IsIconic(d3d11_swapchain_get_hwnd(swapchain)))
 314         return DXGI_STATUS_OCCLUDED;
 315
 316     if (flags & ~DXGI_PRESENT_TEST)
 317         FIXME("Unimplemented flags %#x.\n", flags);
 318     if (flags & DXGI_PRESENT_TEST)
 319     {
 320         WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
 321         return S_OK;
 322     }
 323
 324     if (SUCCEEDED(hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, NULL, NULL, NULL, sync_interval, 0)))
 325         InterlockedIncrement(&swapchain->present_count);
 326     return hr;
 327 }
 328
 329 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d11_swapchain_Present(IDXGISwapChain2 *iface, UINT sync_interval, UINT flags)
 330 {
 331     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 332
 333     TRACE("iface %p, sync_interval %u, flags %#x.\n", iface, sync_interval, flags);
 334
 335     return d3d11_swapchain_present(swapchain, sync_interval, flags);
 336 }
 337
 338 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetBuffer(IDXGISwapChain2 *iface,
 339         UINT buffer_idx, REFIID riid, void **surface)
 340 {
 341     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 342     struct wined3d_texture *texture;
 343     IUnknown *parent;
 344     HRESULT hr;
 345
 346     TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
 347             iface, buffer_idx, debugstr_guid(riid), surface);
 348
 349     wined3d_mutex_lock();
 350
 351     if (!(texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, buffer_idx)))
 352     {
 353         wined3d_mutex_unlock();
 354         return DXGI_ERROR_INVALID_CALL;
 355     }
 356
 357     parent = wined3d_texture_get_parent(texture);
 358     hr = IUnknown_QueryInterface(parent, riid, surface);
 359     wined3d_mutex_unlock();
 360
 361     return hr;
 362 }
 363
 364 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d11_swapchain_SetFullscreenState(IDXGISwapChain2 *iface,
 365         BOOL fullscreen, IDXGIOutput *target)
 366 {
 367     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 368     struct wined3d_swapchain_desc swapchain_desc;
 369     struct wined3d_swapchain_state *state;
 370     struct dxgi_output *dxgi_output;
 371     LONG in_set_fullscreen_state;
 372     BOOL old_fs;
 373     HRESULT hr;
 374
 375     TRACE("iface %p, fullscreen %#x, target %p.\n", iface, fullscreen, target);
 376
 377     if (!fullscreen && target)
 378     {
 379         WARN("Invalid call.\n");
 380         return DXGI_ERROR_INVALID_CALL;
 381     }
 382
 383     if (target)
 384     {
 385         IDXGIOutput_AddRef(target);
 386     }
 387     else if (FAILED(hr = IDXGISwapChain2_GetContainingOutput(iface, &target)))
 388     {
 389         WARN("Failed to get target output for swapchain, hr %#lx.\n", hr);
 390         return hr;
 391     }
 392     dxgi_output = unsafe_impl_from_IDXGIOutput(target);
 393
 394     /* DXGI catches nested SetFullscreenState invocations, earlier versions of d3d
 395      * do not. Final Fantasy XIV depends on this behavior. It tries to call SFS on
 396      * WM_WINDOWPOSCHANGED messages. */
 397     in_set_fullscreen_state = InterlockedExchange(&swapchain->in_set_fullscreen_state, 1);
 398     if (in_set_fullscreen_state)
 399     {
 400         WARN("Nested invocation of SetFullscreenState.\n");
 401         IDXGIOutput_Release(target);
 402         IDXGISwapChain2_GetFullscreenState(iface, &old_fs, NULL);
 403         return old_fs == fullscreen ? S_OK : DXGI_STATUS_MODE_CHANGE_IN_PROGRESS;
 404     }
 405
 406     wined3d_mutex_lock();
 407     state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 408     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &swapchain_desc);
 409     swapchain_desc.output = dxgi_output->wined3d_output;
 410     swapchain_desc.windowed = !fullscreen;
 411     hr = wined3d_swapchain_state_set_fullscreen(state, &swapchain_desc, NULL);
 412     if (FAILED(hr))
 413     {
 414         IDXGIOutput_Release(target);
 415         hr = DXGI_ERROR_NOT_CURRENTLY_AVAILABLE;
 416         goto done;
 417     }
 418
 419     if (!fullscreen)
 420     {
 421         IDXGIOutput_Release(target);
 422         target = NULL;
 423     }
 424
 425     if (swapchain->target)
 426         IDXGIOutput_Release(swapchain->target);
 427     swapchain->target = target;
 428
 429 done:
 430     wined3d_mutex_unlock();
 431     InterlockedExchange(&swapchain->in_set_fullscreen_state, 0);
 432     return hr;
 433 }
 434
 435 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFullscreenState(IDXGISwapChain2 *iface,
 436         BOOL *fullscreen, IDXGIOutput **target)
 437 {
 438     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 439     struct wined3d_swapchain_desc swapchain_desc;
 440     HRESULT hr;
 441
 442     TRACE("iface %p, fullscreen %p, target %p.\n", iface, fullscreen, target);
 443
 444     if (fullscreen || target)
 445     {
 446         wined3d_mutex_lock();
 447         wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &swapchain_desc);
 448         wined3d_mutex_unlock();
 449     }
 450
 451     if (fullscreen)
 452         *fullscreen = !swapchain_desc.windowed;
 453
 454     if (target)
 455     {
 456         if (!swapchain_desc.windowed)
 457         {
 458             if (!swapchain->target && FAILED(hr = IDXGISwapChain2_GetContainingOutput(iface, &swapchain->target)))
 459                 return hr;
 460
 461             *target = swapchain->target;
 462             IDXGIOutput_AddRef(*target);
 463         }
 464         else
 465         {
 466             *target = NULL;
 467         }
 468     }
 469
 470     return S_OK;
 471 }
 472
 473 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDesc(IDXGISwapChain2 *iface, DXGI_SWAP_CHAIN_DESC *desc)
 474 {
 475     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 476     struct wined3d_swapchain_desc wined3d_desc;
 477
 478     TRACE("iface %p, desc %p.\n", iface, desc);
 479
 480     if (!desc)
 481     {
 482         WARN("Invalid pointer.\n");
 483         return E_INVALIDARG;
 484     }
 485
 486     wined3d_mutex_lock();
 487     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 488     wined3d_mutex_unlock();
 489
 490     FIXME("Ignoring ScanlineOrdering and Scaling.\n");
 491
 492     desc->BufferDesc.Width = wined3d_desc.backbuffer_width;
 493     desc->BufferDesc.Height = wined3d_desc.backbuffer_height;
 494     desc->BufferDesc.RefreshRate.Numerator = wined3d_desc.refresh_rate;
 495     desc->BufferDesc.RefreshRate.Denominator = 1;
 496     desc->BufferDesc.Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 497     desc->BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 498     desc->BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 499     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 500             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 501     desc->BufferUsage = dxgi_usage_from_wined3d_bind_flags(wined3d_desc.backbuffer_bind_flags);
 502     desc->BufferCount = wined3d_desc.backbuffer_count;
 503     desc->OutputWindow = wined3d_desc.device_window;
 504     desc->Windowed = wined3d_desc.windowed;
 505     desc->SwapEffect = dxgi_swap_effect_from_wined3d(wined3d_desc.swap_effect);
 506     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 507
 508     return S_OK;
 509 }
 510
 511 static HRESULT d3d11_swapchain_create_d3d11_textures(struct d3d11_swapchain *swapchain,
 512         IWineDXGIDevice *device, struct wined3d_swapchain_desc *desc);
 513
 514 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_ResizeBuffers(IDXGISwapChain2 *iface,
 515         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
 516 {
 517     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 518     struct wined3d_swapchain_desc wined3d_desc;
 519     struct wined3d_texture *texture;
 520     IUnknown *parent;
 521     unsigned int i;
 522     HRESULT hr;
 523
 524     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
 525             iface, buffer_count, width, height, debug_dxgi_format(format), flags);
 526
 527     if (flags)
 528         FIXME("Ignoring flags %#x.\n", flags);
 529
 530     wined3d_mutex_lock();
 531     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 532     for (i = 0; i < wined3d_desc.backbuffer_count; ++i)
 533     {
 534         texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i);
 535         parent = wined3d_texture_get_parent(texture);
 536         IUnknown_AddRef(parent);
 537         if (IUnknown_Release(parent))
 538         {
 539             wined3d_mutex_unlock();
 540             return DXGI_ERROR_INVALID_CALL;
 541         }
 542     }
 543     if (format != DXGI_FORMAT_UNKNOWN)
 544         wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(format);
 545     hr = wined3d_swapchain_resize_buffers(swapchain->wined3d_swapchain, buffer_count, width, height,
 546             wined3d_desc.backbuffer_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 547     /* wined3d_swapchain_resize_buffers() may recreate swapchain textures.
 548      * We do not need to remove the reference to the wined3d swapchain from the
 549      * old d3d11 textures: we just validated above that they have 0 references,
 550      * and therefore they are not actually holding a reference to the wined3d
 551      * swapchain, and will not do anything with it when they are destroyed. */
 552     d3d11_swapchain_create_d3d11_textures(swapchain, swapchain->device, &wined3d_desc);
 553     wined3d_mutex_unlock();
 554
 555     return hr;
 556 }
 557
 558 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_ResizeTarget(IDXGISwapChain2 *iface,
 559         const DXGI_MODE_DESC *target_mode_desc)
 560 {
 561     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 562     struct wined3d_swapchain_state *state;
 563
 564     TRACE("iface %p, target_mode_desc %p.\n", iface, target_mode_desc);
 565
 566     state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 567
 568     return dxgi_swapchain_resize_target(state, target_mode_desc);
 569 }
 570
 571 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetContainingOutput(IDXGISwapChain2 *iface, IDXGIOutput **output)
 572 {
 573     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 574     HWND window;
 575
 576     TRACE("iface %p, output %p.\n", iface, output);
 577
 578     if (swapchain->target)
 579     {
 580         IDXGIOutput_AddRef(*output = swapchain->target);
 581         return S_OK;
 582     }
 583
 584     window = d3d11_swapchain_get_hwnd(swapchain);
 585     return dxgi_get_output_from_window(swapchain->factory, window, output);
 586 }
 587
 588 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFrameStatistics(IDXGISwapChain2 *iface,
 589         DXGI_FRAME_STATISTICS *stats)
 590 {
 591     FIXME("iface %p, stats %p stub!\n", iface, stats);
 592
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetLastPresentCount(IDXGISwapChain2 *iface,
 597         UINT *last_present_count)
 598 {
 599     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 600
 601     TRACE("iface %p, last_present_count %p.\n", iface, last_present_count);
 602
 603     *last_present_count =  swapchain->present_count;
 604
 605     return S_OK;
 606 }
 607
 608 /* IDXGISwapChain1 methods */
 609
 610 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetDesc1(IDXGISwapChain2 *iface, DXGI_SWAP_CHAIN_DESC1 *desc)
 611 {
 612     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 613     struct wined3d_swapchain_desc wined3d_desc;
 614
 615     TRACE("iface %p, desc %p.\n", iface, desc);
 616
 617     if (!desc)
 618     {
 619         WARN("Invalid pointer.\n");
 620         return E_INVALIDARG;
 621     }
 622
 623     wined3d_mutex_lock();
 624     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 625     wined3d_mutex_unlock();
 626
 627     FIXME("Ignoring Stereo, Scaling and AlphaMode.\n");
 628
 629     desc->Width = wined3d_desc.backbuffer_width;
 630     desc->Height = wined3d_desc.backbuffer_height;
 631     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 632     desc->Stereo = FALSE;
 633     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 634             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 635     desc->BufferUsage = dxgi_usage_from_wined3d_bind_flags(wined3d_desc.backbuffer_bind_flags);
 636     desc->BufferCount = wined3d_desc.backbuffer_count;
 637     desc->Scaling = DXGI_SCALING_STRETCH;
 638     desc->SwapEffect = dxgi_swap_effect_from_wined3d(wined3d_desc.swap_effect);
 639     desc->AlphaMode = DXGI_ALPHA_MODE_IGNORE;
 640     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 641
 642     return S_OK;
 643 }
 644
 645 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetFullscreenDesc(IDXGISwapChain2 *iface,
 646         DXGI_SWAP_CHAIN_FULLSCREEN_DESC *desc)
 647 {
 648     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 649     struct wined3d_swapchain_desc wined3d_desc;
 650
 651     TRACE("iface %p, desc %p.\n", iface, desc);
 652
 653     if (!desc)
 654     {
 655         WARN("Invalid pointer.\n");
 656         return E_INVALIDARG;
 657     }
 658
 659     wined3d_mutex_lock();
 660     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 661     wined3d_mutex_unlock();
 662
 663     FIXME("Ignoring ScanlineOrdering and Scaling.\n");
 664
 665     desc->RefreshRate.Numerator = wined3d_desc.refresh_rate;
 666     desc->RefreshRate.Denominator = 1;
 667     desc->ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 668     desc->Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 669     desc->Windowed = wined3d_desc.windowed;
 670
 671     return S_OK;
 672 }
 673
 674 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetHwnd(IDXGISwapChain2 *iface, HWND *hwnd)
 675 {
 676     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 677
 678     TRACE("iface %p, hwnd %p.\n", iface, hwnd);
 679
 680     if (!hwnd)
 681     {
 682         WARN("Invalid pointer.\n");
 683         return DXGI_ERROR_INVALID_CALL;
 684     }
 685
 686     *hwnd = d3d11_swapchain_get_hwnd(swapchain);
 687     return S_OK;
 688 }
 689
 690 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetCoreWindow(IDXGISwapChain2 *iface,
 691         REFIID iid, void **core_window)
 692 {
 693     FIXME("iface %p, iid %s, core_window %p stub!\n", iface, debugstr_guid(iid), core_window);
 694
 695     if (core_window)
 696         *core_window = NULL;
 697
 698     return DXGI_ERROR_INVALID_CALL;
 699 }
 700
 701 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_Present1(IDXGISwapChain2 *iface,
 702         UINT sync_interval, UINT flags, const DXGI_PRESENT_PARAMETERS *present_parameters)
 703 {
 704     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_IDXGISwapChain2(iface);
 705
 706     TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
 707             iface, sync_interval, flags, present_parameters);
 708
 709     if (present_parameters)
 710         FIXME("Ignored present parameters %p.\n", present_parameters);
 711
 712     return d3d11_swapchain_present(swapchain, sync_interval, flags);
 713 }
 714
 715 static BOOL STDMETHODCALLTYPE d3d11_swapchain_IsTemporaryMonoSupported(IDXGISwapChain2 *iface)
 716 {
 717     FIXME("iface %p stub!\n", iface);
 718
 719     return FALSE;
 720 }
 721
 722 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetRestrictToOutput(IDXGISwapChain2 *iface, IDXGIOutput **output)
 723 {
 724     FIXME("iface %p, output %p stub!\n", iface, output);
 725
 726     if (!output)
 727     {
 728         WARN("Invalid pointer.\n");
 729         return E_INVALIDARG;
 730     }
 731
 732     *output = NULL;
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetBackgroundColor(IDXGISwapChain2 *iface, const DXGI_RGBA *color)
 737 {
 738     FIXME("iface %p, color %p stub!\n", iface, color);
 739
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetBackgroundColor(IDXGISwapChain2 *iface, DXGI_RGBA *color)
 744 {
 745     FIXME("iface %p, color %p stub!\n", iface, color);
 746
 747     return E_NOTIMPL;
 748 }
 749
 750 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetRotation(IDXGISwapChain2 *iface, DXGI_MODE_ROTATION rotation)
 751 {
 752     FIXME("iface %p, rotation %#x stub!\n", iface, rotation);
 753
 754     return E_NOTIMPL;
 755 }
 756
 757 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetRotation(IDXGISwapChain2 *iface, DXGI_MODE_ROTATION *rotation)
 758 {
 759     FIXME("iface %p, rotation %p stub!\n", iface, rotation);
 760
 761     return E_NOTIMPL;
 762 }
 763
 764 /* IDXGISwapChain2 methods */
 765
 766 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetSourceSize(IDXGISwapChain2 *iface, UINT width, UINT height)
 767 {
 768     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
 769
 770     return E_NOTIMPL;
 771 }
 772
 773 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetSourceSize(IDXGISwapChain2 *iface, UINT *width, UINT *height)
 774 {
 775     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
 776
 777     return E_NOTIMPL;
 778 }
 779
 780 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetMaximumFrameLatency(IDXGISwapChain2 *iface, UINT max_latency)
 781 {
 782     FIXME("iface %p, max_latency %u stub!\n", iface, max_latency);
 783
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetMaximumFrameLatency(IDXGISwapChain2 *iface, UINT *max_latency)
 788 {
 789     FIXME("iface %p, max_latency %p stub!\n", iface, max_latency);
 790
 791     return E_NOTIMPL;
 792 }
 793
 794 static HANDLE STDMETHODCALLTYPE d3d11_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain2 *iface)
 795 {
 796     FIXME("iface %p stub!\n", iface);
 797
 798     return NULL;
 799 }
 800
 801 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_SetMatrixTransform(IDXGISwapChain2 *iface,
 802         const DXGI_MATRIX_3X2_F *matrix)
 803 {
 804     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
 805
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT STDMETHODCALLTYPE d3d11_swapchain_GetMatrixTransform(IDXGISwapChain2 *iface,
 810         DXGI_MATRIX_3X2_F *matrix)
 811 {
 812     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
 813
 814     return E_NOTIMPL;
 815 }
 816
 817 static const struct IDXGISwapChain2Vtbl d3d11_swapchain_vtbl =
 818 {
 819     /* IUnknown methods */
 820     d3d11_swapchain_QueryInterface,
 821     d3d11_swapchain_AddRef,
 822     d3d11_swapchain_Release,
 823     /* IDXGIObject methods */
 824     d3d11_swapchain_SetPrivateData,
 825     d3d11_swapchain_SetPrivateDataInterface,
 826     d3d11_swapchain_GetPrivateData,
 827     d3d11_swapchain_GetParent,
 828     /* IDXGIDeviceSubObject methods */
 829     d3d11_swapchain_GetDevice,
 830     /* IDXGISwapChain methods */
 831     d3d11_swapchain_Present,
 832     d3d11_swapchain_GetBuffer,
 833     d3d11_swapchain_SetFullscreenState,
 834     d3d11_swapchain_GetFullscreenState,
 835     d3d11_swapchain_GetDesc,
 836     d3d11_swapchain_ResizeBuffers,
 837     d3d11_swapchain_ResizeTarget,
 838     d3d11_swapchain_GetContainingOutput,
 839     d3d11_swapchain_GetFrameStatistics,
 840     d3d11_swapchain_GetLastPresentCount,
 841     /* IDXGISwapChain1 methods */
 842     d3d11_swapchain_GetDesc1,
 843     d3d11_swapchain_GetFullscreenDesc,
 844     d3d11_swapchain_GetHwnd,
 845     d3d11_swapchain_GetCoreWindow,
 846     d3d11_swapchain_Present1,
 847     d3d11_swapchain_IsTemporaryMonoSupported,
 848     d3d11_swapchain_GetRestrictToOutput,
 849     d3d11_swapchain_SetBackgroundColor,
 850     d3d11_swapchain_GetBackgroundColor,
 851     d3d11_swapchain_SetRotation,
 852     d3d11_swapchain_GetRotation,
 853     /* IDXGISwapChain2 methods */
 854     d3d11_swapchain_SetSourceSize,
 855     d3d11_swapchain_GetSourceSize,
 856     d3d11_swapchain_SetMaximumFrameLatency,
 857     d3d11_swapchain_GetMaximumFrameLatency,
 858     d3d11_swapchain_GetFrameLatencyWaitableObject,
 859     d3d11_swapchain_SetMatrixTransform,
 860     d3d11_swapchain_GetMatrixTransform,
 861 };
 862
 863 static void STDMETHODCALLTYPE d3d11_swapchain_wined3d_object_released(void *parent)
 864 {
 865     struct d3d11_swapchain *swapchain = parent;
 866
 867     wined3d_private_store_cleanup(&swapchain->private_store);
 868     free(parent);
 869 }
 870
 871 static const struct wined3d_parent_ops d3d11_swapchain_wined3d_parent_ops =
 872 {
 873     d3d11_swapchain_wined3d_object_released,
 874 };
 875
 876 static inline struct d3d11_swapchain *d3d11_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent *parent)
 877 {
 878     return CONTAINING_RECORD(parent, struct d3d11_swapchain, state_parent);
 879 }
 880
 881 static void CDECL d3d11_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent *parent,
 882         BOOL windowed)
 883 {
 884     struct d3d11_swapchain *swapchain = d3d11_swapchain_from_wined3d_swapchain_state_parent(parent);
 885
 886     TRACE("parent %p, windowed %d.\n", parent, windowed);
 887
 888     if (windowed && swapchain->target)
 889     {
 890         IDXGIOutput_Release(swapchain->target);
 891         swapchain->target = NULL;
 892     }
 893 }
 894
 895 static const struct wined3d_swapchain_state_parent_ops d3d11_swapchain_state_parent_ops =
 896 {
 897     d3d11_swapchain_windowed_state_changed,
 898 };
 899
 900 static HRESULT d3d11_swapchain_create_d3d11_textures(struct d3d11_swapchain *swapchain,
 901         IWineDXGIDevice *device, struct wined3d_swapchain_desc *desc)
 902 {
 903     IWineDXGIDeviceParent *dxgi_device_parent;
 904     unsigned int texture_flags = 0;
 905     unsigned int i;
 906     HRESULT hr;
 907
 908     if (FAILED(hr = IWineDXGIDevice_QueryInterface(device,
 909             &IID_IWineDXGIDeviceParent, (void **)&dxgi_device_parent)))
 910     {
 911         ERR("Device should implement IWineDXGIDeviceParent.\n");
 912         return E_FAIL;
 913     }
 914
 915     if (desc->flags & WINED3D_SWAPCHAIN_GDI_COMPATIBLE)
 916         texture_flags |= WINED3D_TEXTURE_CREATE_GET_DC;
 917
 918     for (i = 0; i < desc->backbuffer_count; ++i)
 919     {
 920         IDXGISurface *surface;
 921
 922         if (FAILED(hr = IWineDXGIDeviceParent_register_swapchain_texture(dxgi_device_parent,
 923                 wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i), texture_flags, &surface)))
 924         {
 925             ERR("Failed to create parent swapchain texture, hr %#lx.\n", hr);
 926             break;
 927         }
 928         IDXGISurface_Release(surface);
 929     }
 930
 931     IWineDXGIDeviceParent_Release(dxgi_device_parent);
 932     return hr;
 933 }
 934
 935 HRESULT d3d11_swapchain_init(struct d3d11_swapchain *swapchain, struct dxgi_device *device,
 936         struct wined3d_swapchain_desc *desc)
 937 {
 938     struct wined3d_swapchain_state *state;
 939     BOOL fullscreen;
 940     HRESULT hr;
 941
 942     if (desc->backbuffer_format == WINED3DFMT_UNKNOWN)
 943         return E_INVALIDARG;
 944
 945     if (FAILED(hr = IWineDXGIAdapter_GetParent(device->adapter,
 946             &IID_IWineDXGIFactory, (void **)&swapchain->factory)))
 947     {
 948         WARN("Failed to get adapter parent, hr %#lx.\n", hr);
 949         return hr;
 950     }
 951     IWineDXGIDevice_AddRef(swapchain->device = &device->IWineDXGIDevice_iface);
 952
 953     swapchain->IDXGISwapChain2_iface.lpVtbl = &d3d11_swapchain_vtbl;
 954     swapchain->state_parent.ops = &d3d11_swapchain_state_parent_ops;
 955     swapchain->refcount = 1;
 956     wined3d_mutex_lock();
 957     wined3d_private_store_init(&swapchain->private_store);
 958
 959     if (!desc->windowed && (!desc->backbuffer_width || !desc->backbuffer_height))
 960         FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
 961
 962     fullscreen = !desc->windowed;
 963     desc->windowed = TRUE;
 964     if (FAILED(hr = wined3d_swapchain_create(device->wined3d_device, desc, &swapchain->state_parent,
 965             swapchain, &d3d11_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain)))
 966     {
 967         WARN("Failed to create wined3d swapchain, hr %#lx.\n", hr);
 968         if (hr == WINED3DERR_INVALIDCALL)
 969             hr = E_INVALIDARG;
 970         goto cleanup;
 971     }
 972
 973     state = wined3d_swapchain_get_state(swapchain->wined3d_swapchain);
 974     wined3d_swapchain_state_get_size(state, &desc->backbuffer_width, &desc->backbuffer_height);
 975
 976     if (FAILED(hr = d3d11_swapchain_create_d3d11_textures(swapchain, &device->IWineDXGIDevice_iface, desc)))
 977     {
 978         ERR("Failed to create d3d11 textures, hr %#lx.\n", hr);
 979         goto cleanup;
 980     }
 981
 982     swapchain->target = NULL;
 983     if (fullscreen)
 984     {
 985         desc->windowed = FALSE;
 986
 987         if (FAILED(hr = IDXGISwapChain2_GetContainingOutput(&swapchain->IDXGISwapChain2_iface,
 988                 &swapchain->target)))
 989         {
 990             WARN("Failed to get target output for fullscreen swapchain, hr %#lx.\n", hr);
 991             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 992             goto cleanup;
 993         }
 994
 995         if (FAILED(hr = wined3d_swapchain_state_set_fullscreen(state, desc, NULL)))
 996         {
 997             WARN("Failed to set fullscreen state, hr %#lx.\n", hr);
 998             IDXGIOutput_Release(swapchain->target);
 999             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
1000             goto cleanup;
1001         }
1002
1003     }
1004     wined3d_mutex_unlock();
1005
1006     return S_OK;
1007
1008 cleanup:
1009     wined3d_private_store_cleanup(&swapchain->private_store);
1010     wined3d_mutex_unlock();
1011     IWineDXGIFactory_Release(swapchain->factory);
1012     IWineDXGIDevice_Release(swapchain->device);
1013     return hr;
1014 }
1015
1016 struct dxgi_vk_funcs
1017 {
1018     PFN_vkAcquireNextImageKHR p_vkAcquireNextImageKHR;
1019     PFN_vkAllocateCommandBuffers p_vkAllocateCommandBuffers;
1020     PFN_vkAllocateMemory p_vkAllocateMemory;
1021     PFN_vkBeginCommandBuffer p_vkBeginCommandBuffer;
1022     PFN_vkBindImageMemory p_vkBindImageMemory;
1023     PFN_vkCmdBlitImage p_vkCmdBlitImage;
1024     PFN_vkCmdPipelineBarrier p_vkCmdPipelineBarrier;
1025     PFN_vkCreateCommandPool p_vkCreateCommandPool;
1026     PFN_vkCreateFence p_vkCreateFence;
1027     PFN_vkCreateImage p_vkCreateImage;
1028     PFN_vkCreateSemaphore p_vkCreateSemaphore;
1029     PFN_vkCreateSwapchainKHR p_vkCreateSwapchainKHR;
1030     PFN_vkCreateWin32SurfaceKHR p_vkCreateWin32SurfaceKHR;
1031     PFN_vkDestroyCommandPool p_vkDestroyCommandPool;
1032     PFN_vkDestroyFence p_vkDestroyFence;
1033     PFN_vkDestroyImage p_vkDestroyImage;
1034     PFN_vkDestroySemaphore p_vkDestroySemaphore;
1035     PFN_vkDestroySurfaceKHR p_vkDestroySurfaceKHR;
1036     PFN_vkResetCommandBuffer p_vkResetCommandBuffer;
1037     PFN_vkDestroySwapchainKHR p_vkDestroySwapchainKHR;
1038     PFN_vkEndCommandBuffer p_vkEndCommandBuffer;
1039     PFN_vkFreeMemory p_vkFreeMemory;
1040     PFN_vkGetImageMemoryRequirements p_vkGetImageMemoryRequirements;
1041     PFN_vkGetInstanceProcAddr p_vkGetInstanceProcAddr;
1042     PFN_vkGetPhysicalDeviceMemoryProperties p_vkGetPhysicalDeviceMemoryProperties;
1043     PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
1044     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR p_vkGetPhysicalDeviceSurfaceFormatsKHR;
1045     PFN_vkGetPhysicalDeviceSurfacePresentModesKHR p_vkGetPhysicalDeviceSurfacePresentModesKHR;
1046     PFN_vkGetPhysicalDeviceSurfaceSupportKHR p_vkGetPhysicalDeviceSurfaceSupportKHR;
1047     PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR p_vkGetPhysicalDeviceWin32PresentationSupportKHR;
1048     PFN_vkGetSwapchainImagesKHR p_vkGetSwapchainImagesKHR;
1049     PFN_vkQueuePresentKHR p_vkQueuePresentKHR;
1050     PFN_vkQueueSubmit p_vkQueueSubmit;
1051     PFN_vkQueueWaitIdle p_vkQueueWaitIdle;
1052     PFN_vkResetFences p_vkResetFences;
1053     PFN_vkWaitForFences p_vkWaitForFences;
1054
1055     void *vulkan_module;
1056 };
1057
1058 static HRESULT hresult_from_vk_result(VkResult vr)
1059 {
1060     switch (vr)
1061     {
1062         case VK_SUCCESS:
1063             return S_OK;
1064         case VK_ERROR_OUT_OF_HOST_MEMORY:
1065         case VK_ERROR_OUT_OF_DEVICE_MEMORY:
1066             return E_OUTOFMEMORY;
1067         default:
1068             FIXME("Unhandled VkResult %d.\n", vr);
1069             return E_FAIL;
1070     }
1071 }
1072
1073 #define INVALID_VK_IMAGE_INDEX (~(uint32_t)0)
1074
1075 struct d3d12_swapchain
1076 {
1077     IDXGISwapChain4 IDXGISwapChain4_iface;
1078     LONG refcount;
1079     struct wined3d_private_store private_store;
1080
1081     struct wined3d_swapchain_state *state;
1082     struct wined3d_swapchain_state_parent state_parent;
1083
1084     VkSurfaceKHR vk_surface;
1085     VkFence vk_fence;
1086     VkInstance vk_instance;
1087     VkDevice vk_device;
1088     VkPhysicalDevice vk_physical_device;
1089
1090     HANDLE worker_thread;
1091     CRITICAL_SECTION worker_cs;
1092     CONDITION_VARIABLE worker_cv;
1093     bool worker_running;
1094     struct list worker_ops;
1095
1096     /* D3D12 side of the swapchain (frontend): these objects are
1097      * visible to the IDXGISwapChain client, so they must never be
1098      * recreated, except when ResizeBuffers*() is called. */
1099     unsigned int buffer_count;
1100     VkDeviceMemory vk_memory;
1101     VkImage vk_images[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1102     ID3D12Resource *buffers[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1103     unsigned int current_buffer_index;
1104     VkFormat vk_format;
1105
1106     /* Vulkan side of the swapchain (backend): these objects are also
1107      * destroyed and recreated when the Vulkan swapchain becomes out
1108      * of date or when the synchronization interval is changed; this
1109      * operation should be transparent to the IDXGISwapChain client
1110      * (except for timings: recreating the Vulkan swapchain creates a
1111      * noticeable delay, unfortunately). */
1112     VkSwapchainKHR vk_swapchain;
1113     VkCommandPool vk_cmd_pool;
1114     VkImage vk_swapchain_images[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1115     VkCommandBuffer vk_cmd_buffers[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1116     VkSemaphore vk_semaphores[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1117     unsigned int vk_swapchain_width;
1118     unsigned int vk_swapchain_height;
1119     VkPresentModeKHR present_mode;
1120     DXGI_SWAP_CHAIN_DESC1 backend_desc;
1121
1122     ID3D12Fence *present_fence;
1123
1124     uint32_t vk_image_index;
1125
1126     struct dxgi_vk_funcs vk_funcs;
1127
1128     ID3D12CommandQueue *command_queue;
1129     ID3D12Device *device;
1130     IWineDXGIFactory *factory;
1131
1132     HWND window;
1133     IDXGIOutput *target;
1134     DXGI_SWAP_CHAIN_DESC1 desc;
1135     DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc;
1136     LONG in_set_fullscreen_state;
1137
1138     ID3D12Fence *frame_latency_fence;
1139     HANDLE frame_latency_event;
1140
1141     uint64_t frame_number;
1142     uint32_t frame_latency;
1143 };
1144
1145 enum d3d12_swapchain_op_type
1146 {
1147     D3D12_SWAPCHAIN_OP_PRESENT,
1148     D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS,
1149 };
1150
1151 struct d3d12_swapchain_op
1152 {
1153     struct list entry;
1154     enum d3d12_swapchain_op_type type;
1155     union
1156     {
1157         struct
1158         {
1159             unsigned int sync_interval;
1160             VkImage vk_image;
1161             unsigned int frame_number;
1162         } present;
1163         struct
1164         {
1165             /* The resize buffers op takes ownership of the memory and
1166              * images used to back the previous ID3D12Resource
1167              * objects, so that they're only released once the worker
1168              * thread is done with them. */
1169             VkDeviceMemory vk_memory;
1170             VkImage vk_images[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1171             DXGI_SWAP_CHAIN_DESC1 desc;
1172         } resize_buffers;
1173     };
1174 };
1175
1176 static void d3d12_swapchain_op_destroy(struct d3d12_swapchain *swapchain, struct d3d12_swapchain_op *op)
1177 {
1178     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1179     unsigned int i;
1180
1181     if (op->type == D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS)
1182     {
1183         assert(swapchain->vk_device);
1184
1185         for (i = 0; i < DXGI_MAX_SWAP_CHAIN_BUFFERS; ++i)
1186             vk_funcs->p_vkDestroyImage(swapchain->vk_device, op->resize_buffers.vk_images[i], NULL);
1187
1188         vk_funcs->p_vkFreeMemory(swapchain->vk_device, op->resize_buffers.vk_memory, NULL);
1189     }
1190
1191     free(op);
1192 }
1193
1194 static HRESULT d3d12_swapchain_op_present_execute(struct d3d12_swapchain *swapchain, struct d3d12_swapchain_op *op);
1195 static HRESULT d3d12_swapchain_op_resize_buffers_execute(struct d3d12_swapchain *swapchain, struct d3d12_swapchain_op *op);
1196
1197 static DWORD WINAPI d3d12_swapchain_worker_proc(void *data)
1198 {
1199     struct d3d12_swapchain *swapchain = data;
1200
1201     EnterCriticalSection(&swapchain->worker_cs);
1202
1203     while (swapchain->worker_running)
1204     {
1205         if (!list_empty(&swapchain->worker_ops))
1206         {
1207             struct d3d12_swapchain_op *op = LIST_ENTRY(list_head(&swapchain->worker_ops), struct d3d12_swapchain_op, entry);
1208
1209             list_remove(&op->entry);
1210
1211             LeaveCriticalSection(&swapchain->worker_cs);
1212
1213             switch (op->type)
1214             {
1215                 case D3D12_SWAPCHAIN_OP_PRESENT:
1216                     d3d12_swapchain_op_present_execute(swapchain, op);
1217                     break;
1218
1219                 case D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS:
1220                     d3d12_swapchain_op_resize_buffers_execute(swapchain, op);
1221                     break;
1222             }
1223
1224             d3d12_swapchain_op_destroy(swapchain, op);
1225
1226             EnterCriticalSection(&swapchain->worker_cs);
1227         }
1228         else if (!SleepConditionVariableCS(&swapchain->worker_cv, &swapchain->worker_cs, INFINITE))
1229         {
1230             ERR("Cannot sleep on condition variable, last error %ld.\n", GetLastError());
1231             break;
1232         }
1233     }
1234
1235     LeaveCriticalSection(&swapchain->worker_cs);
1236
1237     return 0;
1238 }
1239
1240 static DXGI_FORMAT dxgi_format_from_vk_format(VkFormat vk_format)
1241 {
1242     switch (vk_format)
1243     {
1244         case VK_FORMAT_B8G8R8A8_UNORM: return DXGI_FORMAT_B8G8R8A8_UNORM;
1245         case VK_FORMAT_R8G8B8A8_UNORM: return DXGI_FORMAT_R8G8B8A8_UNORM;
1246         case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return DXGI_FORMAT_R10G10B10A2_UNORM;
1247         case VK_FORMAT_R16G16B16A16_SFLOAT: return DXGI_FORMAT_R16G16B16A16_FLOAT;
1248         default:
1249             WARN("Unhandled format %#x.\n", vk_format);
1250             return DXGI_FORMAT_UNKNOWN;
1251     }
1252 }
1253
1254 static VkFormat get_swapchain_fallback_format(VkFormat vk_format)
1255 {
1256     switch (vk_format)
1257     {
1258         case VK_FORMAT_R8G8B8A8_UNORM:
1259         case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
1260         case VK_FORMAT_R16G16B16A16_SFLOAT:
1261             return VK_FORMAT_B8G8R8A8_UNORM;
1262         default:
1263             WARN("Unhandled format %#x.\n", vk_format);
1264             return VK_FORMAT_UNDEFINED;
1265     }
1266 }
1267
1268 static HRESULT select_vk_format(const struct dxgi_vk_funcs *vk_funcs,
1269         VkPhysicalDevice vk_physical_device, VkSurfaceKHR vk_surface,
1270         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, VkFormat *vk_format)
1271 {
1272     VkSurfaceFormatKHR *formats;
1273     uint32_t format_count;
1274     VkFormat format;
1275     unsigned int i;
1276     VkResult vr;
1277
1278     *vk_format = VK_FORMAT_UNDEFINED;
1279
1280     format = vkd3d_get_vk_format(swapchain_desc->Format);
1281
1282     vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device, vk_surface, &format_count, NULL);
1283     if (vr < 0 || !format_count)
1284     {
1285         WARN("Failed to get supported surface formats, vr %d.\n", vr);
1286         return DXGI_ERROR_INVALID_CALL;
1287     }
1288
1289     if (!(formats = calloc(format_count, sizeof(*formats))))
1290         return E_OUTOFMEMORY;
1291
1292     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(vk_physical_device,
1293             vk_surface, &format_count, formats)) < 0)
1294     {
1295         WARN("Failed to enumerate supported surface formats, vr %d.\n", vr);
1296         free(formats);
1297         return hresult_from_vk_result(vr);
1298     }
1299
1300     for (i = 0; i < format_count; ++i)
1301     {
1302         if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
1303             break;
1304     }
1305     if (i == format_count)
1306     {
1307         /* Try to create a swapchain with format conversion. */
1308         format = get_swapchain_fallback_format(format);
1309         WARN("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc->Format));
1310         for (i = 0; i < format_count; ++i)
1311         {
1312             if (formats[i].format == format && formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
1313             {
1314                 format = formats[i].format;
1315                 break;
1316             }
1317         }
1318     }
1319     free(formats);
1320     if (i == format_count)
1321     {
1322         FIXME("Failed to find Vulkan swapchain format for %s.\n", debug_dxgi_format(swapchain_desc->Format));
1323         return DXGI_ERROR_UNSUPPORTED;
1324     }
1325
1326     TRACE("Using Vulkan swapchain format %#x.\n", format);
1327
1328     *vk_format = format;
1329     return S_OK;
1330 }
1331
1332 static HRESULT vk_select_memory_type(const struct dxgi_vk_funcs *vk_funcs,
1333         VkPhysicalDevice vk_physical_device, uint32_t memory_type_mask,
1334         VkMemoryPropertyFlags flags, uint32_t *memory_type_index)
1335 {
1336     VkPhysicalDeviceMemoryProperties memory_properties;
1337     unsigned int i;
1338
1339     vk_funcs->p_vkGetPhysicalDeviceMemoryProperties(vk_physical_device, &memory_properties);
1340     for (i = 0; i < memory_properties.memoryTypeCount; ++i)
1341     {
1342         if (!(memory_type_mask & (1u << i)))
1343             continue;
1344
1345         if ((memory_properties.memoryTypes[i].propertyFlags & flags) == flags)
1346         {
1347             *memory_type_index = i;
1348             return S_OK;
1349         }
1350     }
1351
1352     FIXME("Failed to find memory type (allowed types %#x).\n", memory_type_mask);
1353     return E_FAIL;
1354 }
1355
1356 static BOOL d3d12_swapchain_is_present_mode_supported(struct d3d12_swapchain *swapchain,
1357         VkPresentModeKHR present_mode)
1358 {
1359     VkPhysicalDevice vk_physical_device = swapchain->vk_physical_device;
1360     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1361     VkPresentModeKHR *modes;
1362     uint32_t count, i;
1363     BOOL supported;
1364     VkResult vr;
1365
1366     if (present_mode == VK_PRESENT_MODE_FIFO_KHR)
1367         return TRUE;
1368
1369     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
1370             swapchain->vk_surface, &count, NULL)) < 0)
1371     {
1372         WARN("Failed to get count of available present modes, vr %d.\n", vr);
1373         return FALSE;
1374     }
1375
1376     supported = FALSE;
1377
1378     if (!(modes = calloc(count, sizeof(*modes))))
1379         return FALSE;
1380     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(vk_physical_device,
1381             swapchain->vk_surface, &count, modes)) >= 0)
1382     {
1383         for (i = 0; i < count; ++i)
1384         {
1385             if (modes[i] == present_mode)
1386             {
1387                 supported = TRUE;
1388                 break;
1389             }
1390         }
1391     }
1392     else
1393     {
1394         WARN("Failed to get available present modes, vr %d.\n", vr);
1395     }
1396     free(modes);
1397
1398     return supported;
1399 }
1400
1401 static HRESULT d3d12_swapchain_create_user_buffers(struct d3d12_swapchain *swapchain)
1402 {
1403     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1404     VkDeviceSize image_offset[DXGI_MAX_SWAP_CHAIN_BUFFERS];
1405     VkDevice vk_device = swapchain->vk_device;
1406     VkMemoryAllocateInfo allocate_info;
1407     VkMemoryRequirements requirements;
1408     VkImageCreateInfo image_info;
1409     uint32_t memory_type_mask;
1410     VkDeviceSize memory_size;
1411     unsigned int i;
1412     VkResult vr;
1413     HRESULT hr;
1414
1415     memset(&image_info, 0, sizeof(image_info));
1416     image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
1417     image_info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1418     image_info.imageType = VK_IMAGE_TYPE_2D;
1419     image_info.format = swapchain->vk_format;
1420     image_info.extent.width = swapchain->desc.Width;
1421     image_info.extent.height = swapchain->desc.Height;
1422     image_info.extent.depth = 1;
1423     image_info.mipLevels = 1;
1424     image_info.arrayLayers = 1;
1425     image_info.samples = VK_SAMPLE_COUNT_1_BIT;
1426     image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
1427     image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT
1428             | VK_IMAGE_USAGE_TRANSFER_DST_BIT
1429             | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1430     if (swapchain->desc.BufferUsage & DXGI_USAGE_SHADER_INPUT)
1431             image_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
1432     image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1433     image_info.queueFamilyIndexCount = 0;
1434     image_info.pQueueFamilyIndices = NULL;
1435     image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1436
1437     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1438     {
1439         assert(swapchain->vk_images[i] == VK_NULL_HANDLE);
1440         if ((vr = vk_funcs->p_vkCreateImage(vk_device, &image_info, NULL, &swapchain->vk_images[i])) < 0)
1441         {
1442             WARN("Failed to create Vulkan image, vr %d.\n", vr);
1443             swapchain->vk_images[i] = VK_NULL_HANDLE;
1444             return hresult_from_vk_result(vr);
1445         }
1446     }
1447
1448     memory_size = 0;
1449     memory_type_mask = ~0u;
1450     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1451     {
1452         vk_funcs->p_vkGetImageMemoryRequirements(vk_device, swapchain->vk_images[i], &requirements);
1453
1454         TRACE("Size %s, alignment %s, memory types %#x.\n",
1455                 wine_dbgstr_longlong(requirements.size), wine_dbgstr_longlong(requirements.alignment),
1456                 requirements.memoryTypeBits);
1457
1458         image_offset[i] = (memory_size + (requirements.alignment - 1)) & ~(requirements.alignment - 1);
1459         memory_size = image_offset[i] + requirements.size;
1460
1461         memory_type_mask &= requirements.memoryTypeBits;
1462     }
1463
1464     TRACE("Allocating %s bytes for user images.\n", wine_dbgstr_longlong(memory_size));
1465
1466     allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1467     allocate_info.pNext = NULL;
1468     allocate_info.allocationSize = memory_size;
1469
1470     if (FAILED(hr = vk_select_memory_type(vk_funcs, swapchain->vk_physical_device,
1471             memory_type_mask, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &allocate_info.memoryTypeIndex)))
1472         return hr;
1473
1474     assert(swapchain->vk_memory == VK_NULL_HANDLE);
1475     if ((vr = vk_funcs->p_vkAllocateMemory(vk_device, &allocate_info, NULL, &swapchain->vk_memory)) < 0)
1476     {
1477         WARN("Failed to allocate device memory, vr %d.\n", vr);
1478         swapchain->vk_memory = VK_NULL_HANDLE;
1479         return hresult_from_vk_result(vr);
1480     }
1481
1482     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1483     {
1484         if ((vr = vk_funcs->p_vkBindImageMemory(vk_device, swapchain->vk_images[i],
1485                 swapchain->vk_memory, image_offset[i])) < 0)
1486         {
1487             WARN("Failed to bind image memory, vr %d.\n", vr);
1488             return hresult_from_vk_result(vr);
1489         }
1490     }
1491
1492     return S_OK;
1493 }
1494
1495 static void vk_cmd_image_barrier(const struct dxgi_vk_funcs *vk_funcs, VkCommandBuffer cmd_buffer,
1496         VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask,
1497         VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask,
1498         VkImageLayout old_layout, VkImageLayout new_layout, VkImage image)
1499 {
1500     VkImageMemoryBarrier barrier;
1501
1502     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1503     barrier.pNext = NULL;
1504     barrier.srcAccessMask = src_access_mask;
1505     barrier.dstAccessMask = dst_access_mask;
1506     barrier.oldLayout = old_layout;
1507     barrier.newLayout = new_layout;
1508     barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1509     barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
1510     barrier.image = image;
1511     barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1512     barrier.subresourceRange.baseMipLevel = 0;
1513     barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS;
1514     barrier.subresourceRange.baseArrayLayer = 0;
1515     barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
1516
1517     vk_funcs->p_vkCmdPipelineBarrier(cmd_buffer,
1518             src_stage_mask, dst_stage_mask, 0, 0, NULL, 0, NULL, 1, &barrier);
1519 }
1520
1521 static VkResult d3d12_swapchain_record_swapchain_blit(struct d3d12_swapchain *swapchain,
1522         VkCommandBuffer vk_cmd_buffer, VkImage vk_dst_image, VkImage vk_src_image)
1523 {
1524     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1525     VkCommandBufferBeginInfo begin_info;
1526     VkImageBlit blit;
1527     VkFilter filter;
1528     VkResult vr;
1529
1530     if (swapchain->desc.Width != swapchain->vk_swapchain_width
1531             || swapchain->desc.Height != swapchain->vk_swapchain_height)
1532         filter = VK_FILTER_LINEAR;
1533     else
1534         filter = VK_FILTER_NEAREST;
1535
1536     begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
1537     begin_info.pNext = NULL;
1538     begin_info.flags = 0;
1539     begin_info.pInheritanceInfo = NULL;
1540
1541     if ((vr = vk_funcs->p_vkBeginCommandBuffer(vk_cmd_buffer, &begin_info)) < 0)
1542     {
1543         WARN("Failed to begin command buffer, vr %d.\n", vr);
1544         return vr;
1545     }
1546
1547     vk_cmd_image_barrier(vk_funcs, vk_cmd_buffer,
1548             VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1549             0, VK_ACCESS_TRANSFER_WRITE_BIT,
1550             VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk_dst_image);
1551
1552     blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1553     blit.srcSubresource.mipLevel = 0;
1554     blit.srcSubresource.baseArrayLayer = 0;
1555     blit.srcSubresource.layerCount = 1;
1556     blit.srcOffsets[0].x = 0;
1557     blit.srcOffsets[0].y = 0;
1558     blit.srcOffsets[0].z = 0;
1559     blit.srcOffsets[1].x = swapchain->desc.Width;
1560     blit.srcOffsets[1].y = swapchain->desc.Height;
1561     blit.srcOffsets[1].z = 1;
1562     blit.dstSubresource = blit.srcSubresource;
1563     blit.dstOffsets[0].x = 0;
1564     blit.dstOffsets[0].y = 0;
1565     blit.dstOffsets[0].z = 0;
1566     if (swapchain->desc.Scaling == DXGI_SCALING_NONE)
1567     {
1568         blit.srcOffsets[1].x = min(swapchain->vk_swapchain_width, blit.srcOffsets[1].x);
1569         blit.srcOffsets[1].y = min(swapchain->vk_swapchain_height, blit.srcOffsets[1].y);
1570         blit.dstOffsets[1].x = blit.srcOffsets[1].x;
1571         blit.dstOffsets[1].y = blit.srcOffsets[1].y;
1572     }
1573     else
1574     {
1575         /* FIXME: handle DXGI_SCALING_ASPECT_RATIO_STRETCH. */
1576         blit.dstOffsets[1].x = swapchain->vk_swapchain_width;
1577         blit.dstOffsets[1].y = swapchain->vk_swapchain_height;
1578     }
1579     blit.dstOffsets[1].z = 1;
1580
1581     vk_funcs->p_vkCmdBlitImage(vk_cmd_buffer,
1582             vk_src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1583             vk_dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1584             1, &blit, filter);
1585
1586     vk_cmd_image_barrier(vk_funcs, vk_cmd_buffer,
1587             VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
1588             VK_ACCESS_TRANSFER_WRITE_BIT, 0,
1589             VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, vk_dst_image);
1590
1591     if ((vr = vk_funcs->p_vkEndCommandBuffer(vk_cmd_buffer)) < 0)
1592         WARN("Failed to end command buffer, vr %d.\n", vr);
1593
1594     return vr;
1595 }
1596
1597 static HRESULT d3d12_swapchain_create_command_buffers(struct d3d12_swapchain *swapchain)
1598 {
1599     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1600     VkDevice vk_device = swapchain->vk_device;
1601     VkCommandBufferAllocateInfo allocate_info;
1602     VkSemaphoreCreateInfo semaphore_info;
1603     VkCommandPoolCreateInfo pool_info;
1604     unsigned int i;
1605     VkResult vr;
1606
1607     pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
1608     pool_info.pNext = NULL;
1609     pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
1610     pool_info.queueFamilyIndex = vkd3d_get_vk_queue_family_index(swapchain->command_queue);
1611
1612     assert(swapchain->vk_cmd_pool == VK_NULL_HANDLE);
1613     if ((vr = vk_funcs->p_vkCreateCommandPool(vk_device, &pool_info,
1614             NULL, &swapchain->vk_cmd_pool)) < 0)
1615     {
1616         WARN("Failed to create command pool, vr %d.\n", vr);
1617         swapchain->vk_cmd_pool = VK_NULL_HANDLE;
1618         return hresult_from_vk_result(vr);
1619     }
1620
1621     allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
1622     allocate_info.pNext = NULL;
1623     allocate_info.commandPool = swapchain->vk_cmd_pool;
1624     allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
1625     allocate_info.commandBufferCount = swapchain->buffer_count;
1626
1627     if ((vr = vk_funcs->p_vkAllocateCommandBuffers(vk_device, &allocate_info,
1628             swapchain->vk_cmd_buffers)) < 0)
1629     {
1630         WARN("Failed to allocate command buffers, vr %d.\n", vr);
1631         return hresult_from_vk_result(vr);
1632     }
1633
1634     for (i = 0; i < swapchain->buffer_count; ++i)
1635     {
1636         semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
1637         semaphore_info.pNext = NULL;
1638         semaphore_info.flags = 0;
1639
1640         assert(swapchain->vk_semaphores[i] == VK_NULL_HANDLE);
1641         if ((vr = vk_funcs->p_vkCreateSemaphore(vk_device, &semaphore_info,
1642                 NULL, &swapchain->vk_semaphores[i])) < 0)
1643         {
1644             WARN("Failed to create semaphore, vr %d.\n", vr);
1645             swapchain->vk_semaphores[i] = VK_NULL_HANDLE;
1646             return hresult_from_vk_result(vr);
1647         }
1648     }
1649
1650     return S_OK;
1651 }
1652
1653 static HRESULT d3d12_swapchain_create_image_resources(struct d3d12_swapchain *swapchain)
1654 {
1655     struct vkd3d_image_resource_create_info resource_info;
1656     ID3D12Device *device = swapchain->device;
1657     unsigned int i;
1658     HRESULT hr;
1659
1660     resource_info.type = VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO;
1661     resource_info.next = NULL;
1662     resource_info.desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
1663     resource_info.desc.Alignment = 0;
1664     resource_info.desc.Width = swapchain->desc.Width;
1665     resource_info.desc.Height = swapchain->desc.Height;
1666     resource_info.desc.DepthOrArraySize = 1;
1667     resource_info.desc.MipLevels = 1;
1668     resource_info.desc.Format = dxgi_format_from_vk_format(swapchain->vk_format);
1669     resource_info.desc.SampleDesc.Count = 1;
1670     resource_info.desc.SampleDesc.Quality = 0;
1671     resource_info.desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
1672     resource_info.desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
1673     resource_info.flags = VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION;
1674     resource_info.present_state = D3D12_RESOURCE_STATE_COPY_SOURCE;
1675
1676     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1677     {
1678         assert(swapchain->vk_images[i]);
1679         assert(!swapchain->buffers[i]);
1680
1681         resource_info.vk_image = swapchain->vk_images[i];
1682
1683         if (FAILED(hr = vkd3d_create_image_resource(device, &resource_info, &swapchain->buffers[i])))
1684         {
1685             WARN("Failed to create vkd3d resource for Vulkan image %u, hr %#lx.\n", i, hr);
1686             return hr;
1687         }
1688
1689         vkd3d_resource_incref(swapchain->buffers[i]);
1690         ID3D12Resource_Release(swapchain->buffers[i]);
1691     }
1692
1693     return S_OK;
1694 }
1695
1696 static VkResult d3d12_swapchain_acquire_next_vulkan_image(struct d3d12_swapchain *swapchain)
1697 {
1698     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1699     VkDevice vk_device = swapchain->vk_device;
1700     VkFence vk_fence = swapchain->vk_fence;
1701     VkResult vr;
1702
1703     swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
1704
1705     if ((vr = vk_funcs->p_vkAcquireNextImageKHR(vk_device, swapchain->vk_swapchain, UINT64_MAX,
1706             VK_NULL_HANDLE, vk_fence, &swapchain->vk_image_index)) < 0)
1707     {
1708         WARN("Failed to acquire next Vulkan image, vr %d.\n", vr);
1709         return vr;
1710     }
1711
1712     if ((vr = vk_funcs->p_vkWaitForFences(vk_device, 1, &vk_fence, VK_TRUE, UINT64_MAX)) != VK_SUCCESS)
1713     {
1714         ERR("Failed to wait for fence, vr %d.\n", vr);
1715         return vr;
1716     }
1717     if ((vr = vk_funcs->p_vkResetFences(vk_device, 1, &vk_fence)) < 0)
1718         ERR("Failed to reset fence, vr %d.\n", vr);
1719
1720     return vr;
1721 }
1722
1723 static void d3d12_swapchain_destroy_vulkan_resources(struct d3d12_swapchain *swapchain)
1724 {
1725     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1726     VkQueue vk_queue;
1727     unsigned int i;
1728
1729     if (swapchain->command_queue)
1730     {
1731         vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue);
1732         vk_funcs->p_vkQueueWaitIdle(vk_queue);
1733         vkd3d_release_vk_queue(swapchain->command_queue);
1734     }
1735
1736     if (swapchain->vk_device)
1737     {
1738         for (i = 0; i < swapchain->buffer_count; ++i)
1739         {
1740             vk_funcs->p_vkDestroySemaphore(swapchain->vk_device, swapchain->vk_semaphores[i], NULL);
1741             swapchain->vk_semaphores[i] = VK_NULL_HANDLE;
1742         }
1743
1744         vk_funcs->p_vkDestroyCommandPool(swapchain->vk_device, swapchain->vk_cmd_pool, NULL);
1745         swapchain->vk_cmd_pool = VK_NULL_HANDLE;
1746     }
1747 }
1748
1749 static void d3d12_swapchain_destroy_d3d12_resources(struct d3d12_swapchain *swapchain)
1750 {
1751     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1752     unsigned int i;
1753
1754     for (i = 0; i < swapchain->desc.BufferCount; ++i)
1755     {
1756         if (swapchain->buffers[i])
1757         {
1758             vkd3d_resource_decref(swapchain->buffers[i]);
1759             swapchain->buffers[i] = NULL;
1760         }
1761         if (swapchain->vk_device)
1762         {
1763             vk_funcs->p_vkDestroyImage(swapchain->vk_device, swapchain->vk_images[i], NULL);
1764             swapchain->vk_images[i] = VK_NULL_HANDLE;
1765         }
1766     }
1767     if (swapchain->vk_device)
1768     {
1769         vk_funcs->p_vkFreeMemory(swapchain->vk_device, swapchain->vk_memory, NULL);
1770         swapchain->vk_memory = VK_NULL_HANDLE;
1771     }
1772 }
1773
1774 static HRESULT d3d12_swapchain_create_vulkan_swapchain(struct d3d12_swapchain *swapchain)
1775 {
1776     VkPhysicalDevice vk_physical_device = swapchain->vk_physical_device;
1777     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1778     VkSwapchainCreateInfoKHR vk_swapchain_desc;
1779     VkDevice vk_device = swapchain->vk_device;
1780     unsigned int width, height, image_count;
1781     VkSurfaceCapabilitiesKHR surface_caps;
1782     VkFormat vk_swapchain_format;
1783     VkSwapchainKHR vk_swapchain;
1784     VkImageUsageFlags usage;
1785     VkResult vr;
1786     HRESULT hr;
1787
1788     if (FAILED(hr = select_vk_format(vk_funcs, vk_physical_device,
1789             swapchain->vk_surface, &swapchain->backend_desc, &vk_swapchain_format)))
1790         return hr;
1791
1792     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device,
1793             swapchain->vk_surface, &surface_caps)) < 0)
1794     {
1795         WARN("Failed to get surface capabilities, vr %d.\n", vr);
1796         return hresult_from_vk_result(vr);
1797     }
1798
1799     image_count = swapchain->backend_desc.BufferCount;
1800     image_count = max(image_count, surface_caps.minImageCount);
1801     if (surface_caps.maxImageCount)
1802         image_count = min(image_count, surface_caps.maxImageCount);
1803
1804     if (image_count != swapchain->backend_desc.BufferCount)
1805     {
1806         WARN("Buffer count %u is not supported (%u-%u).\n", swapchain->backend_desc.BufferCount,
1807                 surface_caps.minImageCount, surface_caps.maxImageCount);
1808     }
1809
1810     width = swapchain->backend_desc.Width;
1811     height = swapchain->backend_desc.Height;
1812     width = max(width, surface_caps.minImageExtent.width);
1813     width = min(width, surface_caps.maxImageExtent.width);
1814     height = max(height, surface_caps.minImageExtent.height);
1815     height = min(height, surface_caps.maxImageExtent.height);
1816
1817     if (width != swapchain->backend_desc.Width || height != swapchain->backend_desc.Height)
1818     {
1819         WARN("Swapchain dimensions %ux%u are not supported (%u-%u x %u-%u).\n",
1820                 swapchain->backend_desc.Width, swapchain->backend_desc.Height,
1821                 surface_caps.minImageExtent.width, surface_caps.maxImageExtent.width,
1822                 surface_caps.minImageExtent.height, surface_caps.maxImageExtent.height);
1823     }
1824
1825     TRACE("Vulkan swapchain extent %ux%u.\n", width, height);
1826
1827     if (!(surface_caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR))
1828     {
1829         FIXME("Unsupported alpha mode.\n");
1830         return DXGI_ERROR_UNSUPPORTED;
1831     }
1832
1833     usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
1834     usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1835     usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1836     if (!(usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) || !(usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
1837         WARN("Transfer not supported for swapchain images.\n");
1838     if (swapchain->backend_desc.BufferUsage & DXGI_USAGE_SHADER_INPUT)
1839     {
1840         usage |= surface_caps.supportedUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT;
1841         if (!(usage & VK_IMAGE_USAGE_SAMPLED_BIT))
1842             WARN("Sampling not supported for swapchain images.\n");
1843     }
1844
1845     vk_swapchain_desc.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
1846     vk_swapchain_desc.pNext = NULL;
1847     vk_swapchain_desc.flags = 0;
1848     vk_swapchain_desc.surface = swapchain->vk_surface;
1849     vk_swapchain_desc.minImageCount = image_count;
1850     vk_swapchain_desc.imageFormat = vk_swapchain_format;
1851     vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
1852     vk_swapchain_desc.imageExtent.width = width;
1853     vk_swapchain_desc.imageExtent.height = height;
1854     vk_swapchain_desc.imageArrayLayers = 1;
1855     vk_swapchain_desc.imageUsage = usage;
1856     vk_swapchain_desc.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
1857     vk_swapchain_desc.queueFamilyIndexCount = 0;
1858     vk_swapchain_desc.pQueueFamilyIndices = NULL;
1859     vk_swapchain_desc.preTransform = surface_caps.currentTransform;
1860     vk_swapchain_desc.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
1861     vk_swapchain_desc.presentMode = swapchain->present_mode;
1862     vk_swapchain_desc.clipped = VK_TRUE;
1863     vk_swapchain_desc.oldSwapchain = swapchain->vk_swapchain;
1864     if ((vr = vk_funcs->p_vkCreateSwapchainKHR(vk_device, &vk_swapchain_desc, NULL, &vk_swapchain)) < 0)
1865     {
1866         WARN("Failed to create Vulkan swapchain, vr %d.\n", vr);
1867         return hresult_from_vk_result(vr);
1868     }
1869
1870     if (swapchain->vk_swapchain)
1871         vk_funcs->p_vkDestroySwapchainKHR(swapchain->vk_device, swapchain->vk_swapchain, NULL);
1872
1873     if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain, &image_count, NULL)) < 0)
1874     {
1875         WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr);
1876         return hresult_from_vk_result(vr);
1877     }
1878     if (image_count > ARRAY_SIZE(swapchain->vk_swapchain_images))
1879     {
1880         FIXME("Unsupported Vulkan swapchain image count %u.\n", image_count);
1881         return E_FAIL;
1882     }
1883     swapchain->buffer_count = image_count;
1884     if ((vr = vk_funcs->p_vkGetSwapchainImagesKHR(vk_device, vk_swapchain,
1885             &image_count, swapchain->vk_swapchain_images)) < 0)
1886     {
1887         WARN("Failed to get Vulkan swapchain images, vr %d.\n", vr);
1888         return hresult_from_vk_result(vr);
1889     }
1890
1891     swapchain->vk_swapchain = vk_swapchain;
1892     swapchain->vk_swapchain_width = width;
1893     swapchain->vk_swapchain_height = height;
1894
1895     swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
1896
1897     return S_OK;
1898 }
1899
1900 static HRESULT d3d12_swapchain_create_vulkan_resources(struct d3d12_swapchain *swapchain)
1901 {
1902     HRESULT hr;
1903
1904     if (FAILED(hr = d3d12_swapchain_create_vulkan_swapchain(swapchain)))
1905         return hr;
1906
1907     return d3d12_swapchain_create_command_buffers(swapchain);
1908 }
1909
1910 static HRESULT d3d12_swapchain_create_d3d12_resources(struct d3d12_swapchain *swapchain)
1911 {
1912     HRESULT hr;
1913
1914     if (!(swapchain->vk_format = vkd3d_get_vk_format(swapchain->desc.Format)))
1915     {
1916         WARN("Invalid format %#x.\n", swapchain->desc.Format);
1917         return DXGI_ERROR_INVALID_CALL;
1918     }
1919
1920     if (FAILED(hr = d3d12_swapchain_create_user_buffers(swapchain)))
1921         return hr;
1922
1923     return d3d12_swapchain_create_image_resources(swapchain);
1924 }
1925
1926 static inline struct d3d12_swapchain *d3d12_swapchain_from_IDXGISwapChain4(IDXGISwapChain4 *iface)
1927 {
1928     return CONTAINING_RECORD(iface, struct d3d12_swapchain, IDXGISwapChain4_iface);
1929 }
1930
1931 /* IUnknown methods */
1932
1933 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_QueryInterface(IDXGISwapChain4 *iface, REFIID iid, void **object)
1934 {
1935     TRACE("iface %p, iid %s, object %p.\n", iface, debugstr_guid(iid), object);
1936
1937     if (IsEqualGUID(iid, &IID_IUnknown)
1938             || IsEqualGUID(iid, &IID_IDXGIObject)
1939             || IsEqualGUID(iid, &IID_IDXGIDeviceSubObject)
1940             || IsEqualGUID(iid, &IID_IDXGISwapChain)
1941             || IsEqualGUID(iid, &IID_IDXGISwapChain1)
1942             || IsEqualGUID(iid, &IID_IDXGISwapChain2)
1943             || IsEqualGUID(iid, &IID_IDXGISwapChain3)
1944             || IsEqualGUID(iid, &IID_IDXGISwapChain4))
1945     {
1946         IUnknown_AddRef(iface);
1947         *object = iface;
1948         return S_OK;
1949     }
1950
1951     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
1952
1953     *object = NULL;
1954     return E_NOINTERFACE;
1955 }
1956
1957 static ULONG STDMETHODCALLTYPE d3d12_swapchain_AddRef(IDXGISwapChain4 *iface)
1958 {
1959     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
1960     ULONG refcount = InterlockedIncrement(&swapchain->refcount);
1961
1962     TRACE("%p increasing refcount to %lu.\n", swapchain, refcount);
1963
1964     return refcount;
1965 }
1966
1967 static void d3d12_swapchain_destroy(struct d3d12_swapchain *swapchain)
1968 {
1969     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
1970     void *vulkan_module = vk_funcs->vulkan_module;
1971     struct d3d12_swapchain_op *op, *op2;
1972     DWORD ret;
1973
1974     EnterCriticalSection(&swapchain->worker_cs);
1975     swapchain->worker_running = false;
1976     WakeAllConditionVariable(&swapchain->worker_cv);
1977     LeaveCriticalSection(&swapchain->worker_cs);
1978
1979     if (swapchain->worker_thread)
1980     {
1981         if ((ret = WaitForSingleObject(swapchain->worker_thread, INFINITE)) != WAIT_OBJECT_0)
1982             ERR("Failed to wait for worker thread, return value %ld.\n", ret);
1983
1984         if (!CloseHandle(swapchain->worker_thread))
1985             ERR("Failed to close worker thread, last error %ld.\n", GetLastError());
1986     }
1987
1988     DeleteCriticalSection(&swapchain->worker_cs);
1989
1990     LIST_FOR_EACH_ENTRY_SAFE(op, op2, &swapchain->worker_ops, struct d3d12_swapchain_op, entry)
1991     {
1992         d3d12_swapchain_op_destroy(swapchain, op);
1993     }
1994
1995     d3d12_swapchain_destroy_vulkan_resources(swapchain);
1996     d3d12_swapchain_destroy_d3d12_resources(swapchain);
1997
1998     if (swapchain->present_fence)
1999         ID3D12Fence_Release(swapchain->present_fence);
2000
2001     if (swapchain->frame_latency_event)
2002         CloseHandle(swapchain->frame_latency_event);
2003
2004     if (swapchain->frame_latency_fence)
2005         ID3D12Fence_Release(swapchain->frame_latency_fence);
2006
2007     if (swapchain->command_queue)
2008         ID3D12CommandQueue_Release(swapchain->command_queue);
2009
2010     wined3d_private_store_cleanup(&swapchain->private_store);
2011
2012     if (swapchain->vk_device)
2013     {
2014         vk_funcs->p_vkDestroyFence(swapchain->vk_device, swapchain->vk_fence, NULL);
2015         vk_funcs->p_vkDestroySwapchainKHR(swapchain->vk_device, swapchain->vk_swapchain, NULL);
2016     }
2017
2018     if (swapchain->vk_instance)
2019         vk_funcs->p_vkDestroySurfaceKHR(swapchain->vk_instance, swapchain->vk_surface, NULL);
2020
2021     if (swapchain->target)
2022     {
2023         WARN("Destroying fullscreen swapchain.\n");
2024         IDXGIOutput_Release(swapchain->target);
2025     }
2026
2027     if (swapchain->device)
2028         ID3D12Device_Release(swapchain->device);
2029
2030     if (swapchain->factory)
2031         IWineDXGIFactory_Release(swapchain->factory);
2032
2033     FreeLibrary(vulkan_module);
2034
2035     wined3d_swapchain_state_destroy(swapchain->state);
2036 }
2037
2038 static ULONG STDMETHODCALLTYPE d3d12_swapchain_Release(IDXGISwapChain4 *iface)
2039 {
2040     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2041     ULONG refcount = InterlockedDecrement(&swapchain->refcount);
2042
2043     TRACE("%p decreasing refcount to %lu.\n", swapchain, refcount);
2044
2045     if (!refcount)
2046     {
2047         d3d12_swapchain_destroy(swapchain);
2048         free(swapchain);
2049     }
2050
2051     return refcount;
2052 }
2053
2054 /* IDXGIObject methods */
2055
2056 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetPrivateData(IDXGISwapChain4 *iface,
2057         REFGUID guid, UINT data_size, const void *data)
2058 {
2059     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2060
2061     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2062
2063     return dxgi_set_private_data(&swapchain->private_store, guid, data_size, data);
2064 }
2065
2066 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetPrivateDataInterface(IDXGISwapChain4 *iface,
2067         REFGUID guid, const IUnknown *object)
2068 {
2069     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2070
2071     TRACE("iface %p, guid %s, object %p.\n", iface, debugstr_guid(guid), object);
2072
2073     return dxgi_set_private_data_interface(&swapchain->private_store, guid, object);
2074 }
2075
2076 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetPrivateData(IDXGISwapChain4 *iface,
2077         REFGUID guid, UINT *data_size, void *data)
2078 {
2079     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2080
2081     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2082
2083     return dxgi_get_private_data(&swapchain->private_store, guid, data_size, data);
2084 }
2085
2086 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetParent(IDXGISwapChain4 *iface, REFIID iid, void **parent)
2087 {
2088     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2089
2090     TRACE("iface %p, iid %s, parent %p.\n", iface, debugstr_guid(iid), parent);
2091
2092     return IWineDXGIFactory_QueryInterface(swapchain->factory, iid, parent);
2093 }
2094
2095 /* IDXGIDeviceSubObject methods */
2096
2097 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDevice(IDXGISwapChain4 *iface, REFIID iid, void **device)
2098 {
2099     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2100
2101     TRACE("iface %p, iid %s, device %p.\n", iface, debugstr_guid(iid), device);
2102
2103     return ID3D12Device_QueryInterface(swapchain->device, iid, device);
2104 }
2105
2106 /* IDXGISwapChain methods */
2107
2108 static HRESULT d3d12_swapchain_set_sync_interval(struct d3d12_swapchain *swapchain,
2109         unsigned int sync_interval)
2110 {
2111     VkPresentModeKHR present_mode;
2112
2113     switch (sync_interval)
2114     {
2115         case 0:
2116             present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;
2117             break;
2118         default:
2119             FIXME("Unsupported sync interval %u.\n", sync_interval);
2120         case 1:
2121             present_mode = VK_PRESENT_MODE_FIFO_KHR;
2122             break;
2123     }
2124
2125     if (swapchain->present_mode == present_mode)
2126         return S_OK;
2127
2128     if (!d3d12_swapchain_is_present_mode_supported(swapchain, present_mode))
2129     {
2130         FIXME("Vulkan present mode %#x is not supported.\n", present_mode);
2131         return S_OK;
2132     }
2133
2134     d3d12_swapchain_destroy_vulkan_resources(swapchain);
2135     swapchain->present_mode = present_mode;
2136     return d3d12_swapchain_create_vulkan_resources(swapchain);
2137 }
2138
2139 static VkResult d3d12_swapchain_queue_present(struct d3d12_swapchain *swapchain, VkImage vk_src_image,
2140         uint64_t frame_number)
2141 {
2142     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
2143     VkPresentInfoKHR present_info;
2144     VkCommandBuffer vk_cmd_buffer;
2145     VkSubmitInfo submit_info;
2146     VkImage vk_dst_image;
2147     VkQueue vk_queue;
2148     VkResult vr;
2149     HRESULT hr;
2150
2151     if (swapchain->vk_image_index == INVALID_VK_IMAGE_INDEX)
2152     {
2153         if ((vr = d3d12_swapchain_acquire_next_vulkan_image(swapchain)) < 0)
2154             return vr;
2155     }
2156
2157     assert(swapchain->vk_image_index < swapchain->buffer_count);
2158
2159     vk_cmd_buffer = swapchain->vk_cmd_buffers[swapchain->vk_image_index];
2160     vk_dst_image = swapchain->vk_swapchain_images[swapchain->vk_image_index];
2161
2162     if ((vr = vk_funcs->p_vkResetCommandBuffer(vk_cmd_buffer, 0)) < 0)
2163     {
2164         ERR("Failed to reset command buffer, vr %d.\n", vr);
2165         return vr;
2166     }
2167
2168     if ((vr = d3d12_swapchain_record_swapchain_blit(swapchain,
2169             vk_cmd_buffer, vk_dst_image, vk_src_image)) < 0 )
2170         return vr;
2171
2172     if (FAILED(hr = ID3D12Fence_SetEventOnCompletion(swapchain->present_fence, frame_number + 1, NULL)))
2173     {
2174         ERR("Failed to wait for present event, hr %#lx.\n", hr);
2175         return VK_ERROR_UNKNOWN;
2176     }
2177
2178     vk_queue = vkd3d_acquire_vk_queue(swapchain->command_queue);
2179
2180     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
2181     submit_info.pNext = NULL;
2182     submit_info.waitSemaphoreCount = 0;
2183     submit_info.pWaitSemaphores = NULL;
2184     submit_info.pWaitDstStageMask = NULL;
2185     submit_info.commandBufferCount = 1;
2186     submit_info.pCommandBuffers = &vk_cmd_buffer;
2187     submit_info.signalSemaphoreCount = 1;
2188     submit_info.pSignalSemaphores = &swapchain->vk_semaphores[swapchain->vk_image_index];
2189
2190     if ((vr = vk_funcs->p_vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE)) < 0)
2191     {
2192         ERR("Failed to blit swapchain buffer, vr %d.\n", vr);
2193         vkd3d_release_vk_queue(swapchain->command_queue);
2194         return vr;
2195     }
2196
2197     present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
2198     present_info.pNext = NULL;
2199     present_info.waitSemaphoreCount = 1;
2200     present_info.pWaitSemaphores = &swapchain->vk_semaphores[swapchain->vk_image_index];
2201     present_info.swapchainCount = 1;
2202     present_info.pSwapchains = &swapchain->vk_swapchain;
2203     present_info.pImageIndices = &swapchain->vk_image_index;
2204     present_info.pResults = NULL;
2205
2206     if ((vr = vk_funcs->p_vkQueuePresentKHR(vk_queue, &present_info)) >= 0)
2207         swapchain->vk_image_index = INVALID_VK_IMAGE_INDEX;
2208
2209     vkd3d_release_vk_queue(swapchain->command_queue);
2210
2211     return vr;
2212 }
2213
2214 static HRESULT d3d12_swapchain_op_present_execute(struct d3d12_swapchain *swapchain, struct d3d12_swapchain_op *op)
2215 {
2216     VkResult vr;
2217     HRESULT hr;
2218
2219     if (FAILED(hr = d3d12_swapchain_set_sync_interval(swapchain, op->present.sync_interval)))
2220         return hr;
2221
2222     vr = d3d12_swapchain_queue_present(swapchain, op->present.vk_image, op->present.frame_number);
2223     if (vr == VK_ERROR_OUT_OF_DATE_KHR)
2224     {
2225         TRACE("Recreating Vulkan swapchain.\n");
2226
2227         d3d12_swapchain_destroy_vulkan_resources(swapchain);
2228         if (FAILED(hr = d3d12_swapchain_create_vulkan_resources(swapchain)))
2229             return hr;
2230
2231         if ((vr = d3d12_swapchain_queue_present(swapchain, op->present.vk_image, op->present.frame_number)) < 0)
2232             ERR("Failed to present after recreating swapchain, vr %d.\n", vr);
2233     }
2234
2235     if (vr < 0)
2236     {
2237         ERR("Failed to queue present, vr %d.\n", vr);
2238         return hresult_from_vk_result(vr);
2239     }
2240
2241     if (swapchain->frame_latency_fence)
2242     {
2243         /* Use the same bias as d3d12_swapchain_present(). Add one to
2244          * account for the "++swapchain->frame_number" there. */
2245         uint64_t number = op->present.frame_number + DXGI_MAX_SWAP_CHAIN_BUFFERS + 1;
2246
2247         if (FAILED(hr = ID3D12CommandQueue_Signal(swapchain->command_queue,
2248                 swapchain->frame_latency_fence, number)))
2249         {
2250             ERR("Failed to signal frame latency fence, hr %#lx.\n", hr);
2251             return hr;
2252         }
2253     }
2254
2255     return S_OK;
2256 }
2257
2258 static HRESULT d3d12_swapchain_present(struct d3d12_swapchain *swapchain,
2259         unsigned int sync_interval, unsigned int flags)
2260 {
2261     struct d3d12_swapchain_op *op;
2262     HANDLE frame_latency_event;
2263     HRESULT hr;
2264
2265     if (sync_interval > 4)
2266     {
2267         WARN("Invalid sync interval %u.\n", sync_interval);
2268         return DXGI_ERROR_INVALID_CALL;
2269     }
2270
2271     if (flags & ~DXGI_PRESENT_TEST)
2272         FIXME("Unimplemented flags %#x.\n", flags);
2273     if (flags & DXGI_PRESENT_TEST)
2274     {
2275         WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
2276         return S_OK;
2277     }
2278
2279     if (!(op = calloc(1, sizeof(*op))))
2280     {
2281         WARN("Cannot allocate memory.\n");
2282         return E_OUTOFMEMORY;
2283     }
2284
2285     op->type = D3D12_SWAPCHAIN_OP_PRESENT;
2286     op->present.sync_interval = sync_interval;
2287     op->present.vk_image = swapchain->vk_images[swapchain->current_buffer_index];
2288     op->present.frame_number = swapchain->frame_number;
2289
2290     EnterCriticalSection(&swapchain->worker_cs);
2291     list_add_tail(&swapchain->worker_ops, &op->entry);
2292     WakeAllConditionVariable(&swapchain->worker_cv);
2293     LeaveCriticalSection(&swapchain->worker_cs);
2294
2295     ++swapchain->frame_number;
2296     if ((frame_latency_event = swapchain->frame_latency_event))
2297     {
2298         /* Bias the frame number to avoid underflowing in
2299          * SetEventOnCompletion(). */
2300         uint64_t number = swapchain->frame_number + DXGI_MAX_SWAP_CHAIN_BUFFERS;
2301
2302         if (FAILED(hr = ID3D12Fence_SetEventOnCompletion(swapchain->frame_latency_fence,
2303                 number - swapchain->frame_latency, frame_latency_event)))
2304         {
2305             ERR("Failed to enqueue frame latency event, hr %#lx.\n", hr);
2306             return hr;
2307         }
2308     }
2309
2310     if (FAILED(hr = ID3D12CommandQueue_Signal(swapchain->command_queue,
2311             swapchain->present_fence, swapchain->frame_number)))
2312     {
2313         ERR("Failed to signal present fence, hf %#lx.\n", hr);
2314         return hr;
2315     }
2316
2317     swapchain->current_buffer_index = (swapchain->current_buffer_index + 1) % swapchain->desc.BufferCount;
2318     return S_OK;
2319 }
2320
2321 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_Present(IDXGISwapChain4 *iface, UINT sync_interval, UINT flags)
2322 {
2323     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2324
2325     TRACE("iface %p, sync_interval %u, flags %#x.\n", iface, sync_interval, flags);
2326
2327     return d3d12_swapchain_present(swapchain, sync_interval, flags);
2328 }
2329
2330 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetBuffer(IDXGISwapChain4 *iface,
2331         UINT buffer_idx, REFIID iid, void **surface)
2332 {
2333     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2334
2335     TRACE("iface %p, buffer_idx %u, iid %s, surface %p.\n",
2336             iface, buffer_idx, debugstr_guid(iid), surface);
2337
2338     if (buffer_idx >= swapchain->desc.BufferCount)
2339     {
2340         WARN("Invalid buffer index %u.\n", buffer_idx);
2341         return DXGI_ERROR_INVALID_CALL;
2342     }
2343
2344     assert(swapchain->buffers[buffer_idx]);
2345     return ID3D12Resource_QueryInterface(swapchain->buffers[buffer_idx], iid, surface);
2346 }
2347
2348 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH d3d12_swapchain_SetFullscreenState(IDXGISwapChain4 *iface,
2349         BOOL fullscreen, IDXGIOutput *target)
2350 {
2351     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2352     DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc = &swapchain->fullscreen_desc;
2353     const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc = &swapchain->desc;
2354     struct wined3d_swapchain_desc wined3d_desc;
2355     HWND window = swapchain->window;
2356     LONG in_set_fullscreen_state;
2357     BOOL old_fs;
2358     HRESULT hr;
2359
2360     TRACE("iface %p, fullscreen %#x, target %p.\n", iface, fullscreen, target);
2361
2362     if (!fullscreen && target)
2363     {
2364         WARN("Invalid call.\n");
2365         return DXGI_ERROR_INVALID_CALL;
2366     }
2367
2368     if (target)
2369     {
2370         IDXGIOutput_AddRef(target);
2371     }
2372     else if (FAILED(hr = IDXGISwapChain4_GetContainingOutput(iface, &target)))
2373     {
2374         WARN("Failed to get target output for swapchain, hr %#lx.\n", hr);
2375         return hr;
2376     }
2377
2378     if (FAILED(hr = wined3d_swapchain_desc_from_dxgi(&wined3d_desc, target, window, swapchain_desc,
2379             fullscreen_desc)))
2380     {
2381         IDXGIOutput_Release(target);
2382         return hr;
2383     }
2384
2385     in_set_fullscreen_state = InterlockedExchange(&swapchain->in_set_fullscreen_state, 1);
2386     if (in_set_fullscreen_state)
2387     {
2388         WARN("Nested invocation of SetFullscreenState.\n");
2389         IDXGIOutput_Release(target);
2390         IDXGISwapChain4_GetFullscreenState(iface, &old_fs, NULL);
2391         return old_fs == fullscreen ? S_OK : DXGI_STATUS_MODE_CHANGE_IN_PROGRESS;
2392     }
2393
2394     wined3d_mutex_lock();
2395     wined3d_desc.windowed = !fullscreen;
2396     hr = wined3d_swapchain_state_set_fullscreen(swapchain->state, &wined3d_desc, NULL);
2397     if (FAILED(hr))
2398     {
2399         IDXGIOutput_Release(target);
2400         hr = DXGI_ERROR_NOT_CURRENTLY_AVAILABLE;
2401         goto done;
2402     }
2403
2404     fullscreen_desc->Windowed = wined3d_desc.windowed;
2405     if (!fullscreen)
2406     {
2407         IDXGIOutput_Release(target);
2408         target = NULL;
2409     }
2410
2411     if (swapchain->target)
2412         IDXGIOutput_Release(swapchain->target);
2413     swapchain->target = target;
2414
2415 done:
2416     wined3d_mutex_unlock();
2417     InterlockedExchange(&swapchain->in_set_fullscreen_state, 0);
2418     return hr;
2419 }
2420
2421 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFullscreenState(IDXGISwapChain4 *iface,
2422         BOOL *fullscreen, IDXGIOutput **target)
2423 {
2424     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2425     BOOL windowed;
2426     HRESULT hr;
2427
2428     TRACE("iface %p, fullscreen %p, target %p.\n", iface, fullscreen, target);
2429
2430     if (fullscreen || target)
2431     {
2432         wined3d_mutex_lock();
2433         windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2434         wined3d_mutex_unlock();
2435     }
2436
2437     if (fullscreen)
2438         *fullscreen = !windowed;
2439
2440     if (target)
2441     {
2442         if (!windowed)
2443         {
2444             if (!swapchain->target && FAILED(hr = IDXGISwapChain4_GetContainingOutput(iface,
2445                     &swapchain->target)))
2446                 return hr;
2447
2448             *target = swapchain->target;
2449             IDXGIOutput_AddRef(*target);
2450         }
2451         else
2452         {
2453             *target = NULL;
2454         }
2455     }
2456
2457     return S_OK;
2458 }
2459
2460 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDesc(IDXGISwapChain4 *iface, DXGI_SWAP_CHAIN_DESC *desc)
2461 {
2462     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2463     const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc = &swapchain->fullscreen_desc;
2464     const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc = &swapchain->desc;
2465     BOOL windowed;
2466
2467     TRACE("iface %p, desc %p.\n", iface, desc);
2468
2469     if (!desc)
2470     {
2471         WARN("Invalid pointer.\n");
2472         return E_INVALIDARG;
2473     }
2474
2475     wined3d_mutex_lock();
2476     windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2477     wined3d_mutex_unlock();
2478
2479     desc->BufferDesc.Width = swapchain_desc->Width;
2480     desc->BufferDesc.Height = swapchain_desc->Height;
2481     desc->BufferDesc.RefreshRate = fullscreen_desc->RefreshRate;
2482     desc->BufferDesc.Format = swapchain_desc->Format;
2483     desc->BufferDesc.ScanlineOrdering = fullscreen_desc->ScanlineOrdering;
2484     desc->BufferDesc.Scaling = fullscreen_desc->Scaling;
2485     desc->SampleDesc = swapchain_desc->SampleDesc;
2486     desc->BufferUsage = swapchain_desc->BufferUsage;
2487     desc->BufferCount = swapchain_desc->BufferCount;
2488     desc->OutputWindow = swapchain->window;
2489     desc->Windowed = windowed;
2490     desc->SwapEffect = swapchain_desc->SwapEffect;
2491     desc->Flags = swapchain_desc->Flags;
2492
2493     return S_OK;
2494 }
2495
2496 static HRESULT d3d12_swapchain_op_resize_buffers_execute(struct d3d12_swapchain *swapchain, struct d3d12_swapchain_op *op)
2497 {
2498     d3d12_swapchain_destroy_vulkan_resources(swapchain);
2499
2500     swapchain->backend_desc = op->resize_buffers.desc;
2501
2502     return d3d12_swapchain_create_vulkan_resources(swapchain);
2503 }
2504
2505 static HRESULT d3d12_swapchain_resize_buffers(struct d3d12_swapchain *swapchain,
2506         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
2507 {
2508     DXGI_SWAP_CHAIN_DESC1 *desc, new_desc;
2509     struct d3d12_swapchain_op *op;
2510     unsigned int i;
2511     ULONG refcount;
2512
2513     if (flags)
2514         FIXME("Ignoring flags %#x.\n", flags);
2515
2516     for (i = 0; i < swapchain->desc.BufferCount; ++i)
2517     {
2518         ID3D12Resource_AddRef(swapchain->buffers[i]);
2519         if ((refcount = ID3D12Resource_Release(swapchain->buffers[i])))
2520         {
2521             WARN("Buffer %p has %lu references left.\n", swapchain->buffers[i], refcount);
2522             return DXGI_ERROR_INVALID_CALL;
2523         }
2524     }
2525
2526     desc = &swapchain->desc;
2527     new_desc = swapchain->desc;
2528
2529     if (buffer_count)
2530         new_desc.BufferCount = buffer_count;
2531     if (!width || !height)
2532     {
2533         RECT client_rect;
2534
2535         if (!GetClientRect(swapchain->window, &client_rect))
2536         {
2537             WARN("Failed to get client rect, last error %#lx.\n", GetLastError());
2538             return DXGI_ERROR_INVALID_CALL;
2539         }
2540
2541         if (!width)
2542             width = client_rect.right;
2543         if (!height)
2544             height = client_rect.bottom;
2545     }
2546     new_desc.Width = width;
2547     new_desc.Height = height;
2548
2549     if (format)
2550         new_desc.Format = format;
2551
2552     if (!dxgi_validate_swapchain_desc(&new_desc))
2553         return DXGI_ERROR_INVALID_CALL;
2554
2555     if (desc->Width == new_desc.Width && desc->Height == new_desc.Height
2556             && desc->Format == new_desc.Format && desc->BufferCount == new_desc.BufferCount)
2557     {
2558         swapchain->current_buffer_index = 0;
2559         return S_OK;
2560     }
2561
2562     if (!(op = calloc(1, sizeof(*op))))
2563     {
2564         WARN("Cannot allocate memory.\n");
2565         return E_OUTOFMEMORY;
2566     }
2567
2568     op->type = D3D12_SWAPCHAIN_OP_RESIZE_BUFFERS;
2569     op->resize_buffers.vk_memory = swapchain->vk_memory;
2570     swapchain->vk_memory = VK_NULL_HANDLE;
2571     memcpy(&op->resize_buffers.vk_images, &swapchain->vk_images, sizeof(swapchain->vk_images));
2572     memset(&swapchain->vk_images, 0, sizeof(swapchain->vk_images));
2573     op->resize_buffers.desc = new_desc;
2574
2575     EnterCriticalSection(&swapchain->worker_cs);
2576     list_add_tail(&swapchain->worker_ops, &op->entry);
2577     WakeAllConditionVariable(&swapchain->worker_cv);
2578     LeaveCriticalSection(&swapchain->worker_cs);
2579
2580     swapchain->current_buffer_index = 0;
2581
2582     d3d12_swapchain_destroy_d3d12_resources(swapchain);
2583
2584     swapchain->desc = new_desc;
2585
2586     return d3d12_swapchain_create_d3d12_resources(swapchain);
2587 }
2588
2589 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers(IDXGISwapChain4 *iface,
2590         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
2591 {
2592     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2593
2594     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
2595             iface, buffer_count, width, height, debug_dxgi_format(format), flags);
2596
2597     return d3d12_swapchain_resize_buffers(swapchain, buffer_count, width, height, format, flags);
2598 }
2599
2600 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeTarget(IDXGISwapChain4 *iface,
2601         const DXGI_MODE_DESC *target_mode_desc)
2602 {
2603     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2604
2605     TRACE("iface %p, target_mode_desc %p.\n", iface, target_mode_desc);
2606
2607     return dxgi_swapchain_resize_target(swapchain->state, target_mode_desc);
2608 }
2609
2610 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetContainingOutput(IDXGISwapChain4 *iface,
2611         IDXGIOutput **output)
2612 {
2613     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2614     IUnknown *device_parent;
2615     IWineDXGIFactory *factory;
2616     IDXGIAdapter *adapter;
2617     HRESULT hr;
2618
2619     TRACE("iface %p, output %p.\n", iface, output);
2620
2621     if (swapchain->target)
2622     {
2623         IDXGIOutput_AddRef(*output = swapchain->target);
2624         return S_OK;
2625     }
2626
2627     device_parent = vkd3d_get_device_parent(swapchain->device);
2628
2629     if (FAILED(hr = IUnknown_QueryInterface(device_parent, &IID_IDXGIAdapter, (void **)&adapter)))
2630     {
2631         WARN("Failed to get adapter, hr %#lx.\n", hr);
2632         return hr;
2633     }
2634
2635     if (FAILED(hr = IDXGIAdapter_GetParent(adapter, &IID_IWineDXGIFactory, (void **)&factory)))
2636     {
2637         WARN("Failed to get factory, hr %#lx.\n", hr);
2638         IDXGIAdapter_Release(adapter);
2639         return hr;
2640     }
2641
2642     hr = dxgi_get_output_from_window(factory, swapchain->window, output);
2643     IWineDXGIFactory_Release(factory);
2644     IDXGIAdapter_Release(adapter);
2645     return hr;
2646 }
2647
2648 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFrameStatistics(IDXGISwapChain4 *iface,
2649         DXGI_FRAME_STATISTICS *stats)
2650 {
2651     FIXME("iface %p, stats %p stub!\n", iface, stats);
2652
2653     return E_NOTIMPL;
2654 }
2655
2656 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetLastPresentCount(IDXGISwapChain4 *iface,
2657         UINT *last_present_count)
2658 {
2659     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2660
2661     TRACE("iface %p, last_present_count %p.\n", iface, last_present_count);
2662
2663     *last_present_count = swapchain->frame_number;
2664
2665     return S_OK;
2666 }
2667
2668 /* IDXGISwapChain1 methods */
2669
2670 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetDesc1(IDXGISwapChain4 *iface, DXGI_SWAP_CHAIN_DESC1 *desc)
2671 {
2672     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2673
2674     TRACE("iface %p, desc %p.\n", iface, desc);
2675
2676     if (!desc)
2677     {
2678         WARN("Invalid pointer.\n");
2679         return E_INVALIDARG;
2680     }
2681
2682     *desc = swapchain->desc;
2683     return S_OK;
2684 }
2685
2686 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetFullscreenDesc(IDXGISwapChain4 *iface,
2687         DXGI_SWAP_CHAIN_FULLSCREEN_DESC *desc)
2688 {
2689     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2690     BOOL windowed;
2691
2692     TRACE("iface %p, desc %p.\n", iface, desc);
2693
2694     if (!desc)
2695     {
2696         WARN("Invalid pointer.\n");
2697         return E_INVALIDARG;
2698     }
2699
2700     wined3d_mutex_lock();
2701     windowed = wined3d_swapchain_state_is_windowed(swapchain->state);
2702     wined3d_mutex_unlock();
2703
2704     *desc = swapchain->fullscreen_desc;
2705     desc->Windowed = windowed;
2706     return S_OK;
2707 }
2708
2709 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetHwnd(IDXGISwapChain4 *iface, HWND *hwnd)
2710 {
2711     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2712
2713     TRACE("iface %p, hwnd %p.\n", iface, hwnd);
2714
2715     if (!hwnd)
2716     {
2717         WARN("Invalid pointer.\n");
2718         return DXGI_ERROR_INVALID_CALL;
2719     }
2720
2721     *hwnd = swapchain->window;
2722     return S_OK;
2723 }
2724
2725 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetCoreWindow(IDXGISwapChain4 *iface,
2726         REFIID iid, void **core_window)
2727 {
2728     FIXME("iface %p, iid %s, core_window %p stub!\n", iface, debugstr_guid(iid), core_window);
2729
2730     if (core_window)
2731         *core_window = NULL;
2732
2733     return DXGI_ERROR_INVALID_CALL;
2734 }
2735
2736 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_Present1(IDXGISwapChain4 *iface,
2737         UINT sync_interval, UINT flags, const DXGI_PRESENT_PARAMETERS *present_parameters)
2738 {
2739     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2740
2741     TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
2742             iface, sync_interval, flags, present_parameters);
2743
2744     if (present_parameters)
2745         FIXME("Ignored present parameters %p.\n", present_parameters);
2746
2747     return d3d12_swapchain_present(swapchain, sync_interval, flags);
2748 }
2749
2750 static BOOL STDMETHODCALLTYPE d3d12_swapchain_IsTemporaryMonoSupported(IDXGISwapChain4 *iface)
2751 {
2752     FIXME("iface %p stub!\n", iface);
2753
2754     return FALSE;
2755 }
2756
2757 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetRestrictToOutput(IDXGISwapChain4 *iface, IDXGIOutput **output)
2758 {
2759     FIXME("iface %p, output %p stub!\n", iface, output);
2760
2761     if (!output)
2762     {
2763         WARN("Invalid pointer.\n");
2764         return E_INVALIDARG;
2765     }
2766
2767     *output = NULL;
2768     return E_NOTIMPL;
2769 }
2770
2771 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetBackgroundColor(IDXGISwapChain4 *iface, const DXGI_RGBA *color)
2772 {
2773     FIXME("iface %p, color %p stub!\n", iface, color);
2774
2775     return E_NOTIMPL;
2776 }
2777
2778 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetBackgroundColor(IDXGISwapChain4 *iface, DXGI_RGBA *color)
2779 {
2780     FIXME("iface %p, color %p stub!\n", iface, color);
2781
2782     return E_NOTIMPL;
2783 }
2784
2785 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetRotation(IDXGISwapChain4 *iface, DXGI_MODE_ROTATION rotation)
2786 {
2787     FIXME("iface %p, rotation %#x stub!\n", iface, rotation);
2788
2789     return E_NOTIMPL;
2790 }
2791
2792 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetRotation(IDXGISwapChain4 *iface, DXGI_MODE_ROTATION *rotation)
2793 {
2794     FIXME("iface %p, rotation %p stub!\n", iface, rotation);
2795
2796     return E_NOTIMPL;
2797 }
2798
2799 /* IDXGISwapChain2 methods */
2800
2801 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetSourceSize(IDXGISwapChain4 *iface, UINT width, UINT height)
2802 {
2803     FIXME("iface %p, width %u, height %u stub!\n", iface, width, height);
2804
2805     return E_NOTIMPL;
2806 }
2807
2808 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetSourceSize(IDXGISwapChain4 *iface, UINT *width, UINT *height)
2809 {
2810     FIXME("iface %p, width %p, height %p stub!\n", iface, width, height);
2811
2812     return E_NOTIMPL;
2813 }
2814
2815 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetMaximumFrameLatency(IDXGISwapChain4 *iface, UINT max_latency)
2816 {
2817     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2818
2819     TRACE("iface %p, max_latency %u.\n", iface, max_latency);
2820
2821     if (!(swapchain->desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
2822     {
2823         WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface);
2824         return DXGI_ERROR_INVALID_CALL;
2825     }
2826
2827     if (!max_latency)
2828     {
2829         WARN("Invalid maximum frame latency %u.\n", max_latency);
2830         return DXGI_ERROR_INVALID_CALL;
2831     }
2832
2833     swapchain->frame_latency = max_latency;
2834     return S_OK;
2835 }
2836
2837 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetMaximumFrameLatency(IDXGISwapChain4 *iface, UINT *max_latency)
2838 {
2839     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2840
2841     TRACE("iface %p, max_latency %p.\n", iface, max_latency);
2842
2843     if (!(swapchain->desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
2844     {
2845         WARN("DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT not set for swap chain %p.\n", iface);
2846         return DXGI_ERROR_INVALID_CALL;
2847     }
2848
2849     *max_latency = swapchain->frame_latency;
2850     return S_OK;
2851 }
2852
2853 static HANDLE STDMETHODCALLTYPE d3d12_swapchain_GetFrameLatencyWaitableObject(IDXGISwapChain4 *iface)
2854 {
2855     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2856     HANDLE dup;
2857     BOOL ret;
2858
2859     TRACE("iface %p.\n", iface);
2860
2861     if (!swapchain->frame_latency_event)
2862         return NULL;
2863
2864     ret = DuplicateHandle(GetCurrentProcess(), swapchain->frame_latency_event, GetCurrentProcess(),
2865             &dup, 0, FALSE, DUPLICATE_SAME_ACCESS);
2866
2867     if (!ret)
2868     {
2869         ERR("Cannot duplicate handle, last error %lu.\n", GetLastError());
2870         return NULL;
2871     }
2872
2873     return dup;
2874 }
2875
2876 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetMatrixTransform(IDXGISwapChain4 *iface,
2877         const DXGI_MATRIX_3X2_F *matrix)
2878 {
2879     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
2880
2881     return E_NOTIMPL;
2882 }
2883
2884 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_GetMatrixTransform(IDXGISwapChain4 *iface,
2885         DXGI_MATRIX_3X2_F *matrix)
2886 {
2887     FIXME("iface %p, matrix %p stub!\n", iface, matrix);
2888
2889     return E_NOTIMPL;
2890 }
2891
2892 /* IDXGISwapChain3 methods */
2893
2894 static UINT STDMETHODCALLTYPE d3d12_swapchain_GetCurrentBackBufferIndex(IDXGISwapChain4 *iface)
2895 {
2896     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2897
2898     TRACE("iface %p.\n", iface);
2899
2900     TRACE("Current back buffer index %u.\n", swapchain->current_buffer_index);
2901     assert(swapchain->current_buffer_index < swapchain->desc.BufferCount);
2902     return swapchain->current_buffer_index;
2903 }
2904
2905 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_CheckColorSpaceSupport(IDXGISwapChain4 *iface,
2906         DXGI_COLOR_SPACE_TYPE colour_space, UINT *colour_space_support)
2907 {
2908     UINT support_flags = 0;
2909
2910     FIXME("iface %p, colour_space %#x, colour_space_support %p semi-stub!\n",
2911             iface, colour_space, colour_space_support);
2912
2913     if (!colour_space_support)
2914         return E_INVALIDARG;
2915
2916     if (colour_space == DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709)
2917       support_flags |= DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT;
2918
2919     *colour_space_support = support_flags;
2920     return S_OK;
2921 }
2922
2923 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetColorSpace1(IDXGISwapChain4 *iface,
2924         DXGI_COLOR_SPACE_TYPE colour_space)
2925 {
2926     FIXME("iface %p, colour_space %#x semi-stub!\n", iface, colour_space);
2927
2928     if (colour_space != DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709)
2929     {
2930         WARN("Colour space %u not supported.\n", colour_space);
2931         return E_INVALIDARG;
2932     }
2933
2934     return S_OK;
2935 }
2936
2937 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_ResizeBuffers1(IDXGISwapChain4 *iface,
2938         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags,
2939         const UINT *node_mask, IUnknown * const *present_queue)
2940 {
2941     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_IDXGISwapChain4(iface);
2942     size_t i, count;
2943
2944     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x, "
2945             "node_mask %p, present_queue %p.\n",
2946             iface, buffer_count, width, height, debug_dxgi_format(format), flags, node_mask, present_queue);
2947
2948     if (!node_mask || !present_queue)
2949         return DXGI_ERROR_INVALID_CALL;
2950
2951     count = buffer_count ? buffer_count : swapchain->desc.BufferCount;
2952     for (i = 0; i < count; ++i)
2953     {
2954         if (node_mask[i] > 1 || !present_queue[i])
2955             return DXGI_ERROR_INVALID_CALL;
2956         if ((ID3D12CommandQueue*)present_queue[i] != swapchain->command_queue)
2957             FIXME("Ignoring present queue %p.\n", present_queue[i]);
2958     }
2959
2960     return d3d12_swapchain_resize_buffers(swapchain, buffer_count, width, height, format, flags);
2961 }
2962
2963 /* IDXGISwapChain4 methods */
2964
2965 static HRESULT STDMETHODCALLTYPE d3d12_swapchain_SetHDRMetaData(IDXGISwapChain4 *iface,
2966         DXGI_HDR_METADATA_TYPE type, UINT size, void *metadata)
2967 {
2968     FIXME("iface %p, type %#x, size %#x, metadata %p stub!\n", iface, type, size, metadata);
2969
2970     return E_NOTIMPL;
2971 }
2972
2973 static const struct IDXGISwapChain4Vtbl d3d12_swapchain_vtbl =
2974 {
2975     /* IUnknown methods */
2976     d3d12_swapchain_QueryInterface,
2977     d3d12_swapchain_AddRef,
2978     d3d12_swapchain_Release,
2979     /* IDXGIObject methods */
2980     d3d12_swapchain_SetPrivateData,
2981     d3d12_swapchain_SetPrivateDataInterface,
2982     d3d12_swapchain_GetPrivateData,
2983     d3d12_swapchain_GetParent,
2984     /* IDXGIDeviceSubObject methods */
2985     d3d12_swapchain_GetDevice,
2986     /* IDXGISwapChain methods */
2987     d3d12_swapchain_Present,
2988     d3d12_swapchain_GetBuffer,
2989     d3d12_swapchain_SetFullscreenState,
2990     d3d12_swapchain_GetFullscreenState,
2991     d3d12_swapchain_GetDesc,
2992     d3d12_swapchain_ResizeBuffers,
2993     d3d12_swapchain_ResizeTarget,
2994     d3d12_swapchain_GetContainingOutput,
2995     d3d12_swapchain_GetFrameStatistics,
2996     d3d12_swapchain_GetLastPresentCount,
2997     /* IDXGISwapChain1 methods */
2998     d3d12_swapchain_GetDesc1,
2999     d3d12_swapchain_GetFullscreenDesc,
3000     d3d12_swapchain_GetHwnd,
3001     d3d12_swapchain_GetCoreWindow,
3002     d3d12_swapchain_Present1,
3003     d3d12_swapchain_IsTemporaryMonoSupported,
3004     d3d12_swapchain_GetRestrictToOutput,
3005     d3d12_swapchain_SetBackgroundColor,
3006     d3d12_swapchain_GetBackgroundColor,
3007     d3d12_swapchain_SetRotation,
3008     d3d12_swapchain_GetRotation,
3009     /* IDXGISwapChain2 methods */
3010     d3d12_swapchain_SetSourceSize,
3011     d3d12_swapchain_GetSourceSize,
3012     d3d12_swapchain_SetMaximumFrameLatency,
3013     d3d12_swapchain_GetMaximumFrameLatency,
3014     d3d12_swapchain_GetFrameLatencyWaitableObject,
3015     d3d12_swapchain_SetMatrixTransform,
3016     d3d12_swapchain_GetMatrixTransform,
3017     /* IDXGISwapChain3 methods */
3018     d3d12_swapchain_GetCurrentBackBufferIndex,
3019     d3d12_swapchain_CheckColorSpaceSupport,
3020     d3d12_swapchain_SetColorSpace1,
3021     d3d12_swapchain_ResizeBuffers1,
3022     /* IDXGISwapChain4 methods */
3023     d3d12_swapchain_SetHDRMetaData,
3024 };
3025
3026 static BOOL init_vk_funcs(struct dxgi_vk_funcs *dxgi, VkInstance vk_instance, VkDevice vk_device)
3027 {
3028     PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
3029     PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
3030
3031     dxgi->vulkan_module = LoadLibraryA("vulkan-1.dll");
3032     if (!(vkGetInstanceProcAddr = (void *)GetProcAddress(dxgi->vulkan_module, "vkGetInstanceProcAddr")))
3033     {
3034         ERR_(winediag)("Failed to load Vulkan.\n");
3035         return FALSE;
3036     }
3037
3038     vkGetDeviceProcAddr = (void *)vkGetInstanceProcAddr(vk_instance, "vkGetDeviceProcAddr");
3039
3040 #define LOAD_INSTANCE_PFN(name) \
3041     if (!(dxgi->p_##name = (void *)vkGetInstanceProcAddr(vk_instance, #name))) \
3042     { \
3043         ERR("Failed to get instance proc "#name".\n"); \
3044         FreeLibrary(dxgi->vulkan_module); \
3045         return FALSE; \
3046     }
3047     LOAD_INSTANCE_PFN(vkCreateWin32SurfaceKHR)
3048     LOAD_INSTANCE_PFN(vkDestroySurfaceKHR)
3049     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties)
3050     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
3051     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
3052     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfacePresentModesKHR)
3053     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
3054     LOAD_INSTANCE_PFN(vkGetPhysicalDeviceWin32PresentationSupportKHR)
3055 #undef LOAD_INSTANCE_PFN
3056
3057 #define LOAD_DEVICE_PFN(name) \
3058     if (!(dxgi->p_##name = (void *)vkGetDeviceProcAddr(vk_device, #name))) \
3059     { \
3060         ERR("Failed to get device proc "#name".\n"); \
3061         FreeLibrary(dxgi->vulkan_module); \
3062         return FALSE; \
3063     }
3064     LOAD_DEVICE_PFN(vkAcquireNextImageKHR)
3065     LOAD_DEVICE_PFN(vkAllocateCommandBuffers)
3066     LOAD_DEVICE_PFN(vkAllocateMemory)
3067     LOAD_DEVICE_PFN(vkBeginCommandBuffer)
3068     LOAD_DEVICE_PFN(vkBindImageMemory)
3069     LOAD_DEVICE_PFN(vkCmdBlitImage)
3070     LOAD_DEVICE_PFN(vkCmdPipelineBarrier)
3071     LOAD_DEVICE_PFN(vkCreateCommandPool)
3072     LOAD_DEVICE_PFN(vkCreateFence)
3073     LOAD_DEVICE_PFN(vkCreateImage)
3074     LOAD_DEVICE_PFN(vkCreateSemaphore)
3075     LOAD_DEVICE_PFN(vkCreateSwapchainKHR)
3076     LOAD_DEVICE_PFN(vkDestroyCommandPool)
3077     LOAD_DEVICE_PFN(vkDestroyFence)
3078     LOAD_DEVICE_PFN(vkDestroyImage)
3079     LOAD_DEVICE_PFN(vkDestroySemaphore)
3080     LOAD_DEVICE_PFN(vkDestroySwapchainKHR)
3081     LOAD_DEVICE_PFN(vkEndCommandBuffer)
3082     LOAD_DEVICE_PFN(vkFreeMemory)
3083     LOAD_DEVICE_PFN(vkResetCommandBuffer)
3084     LOAD_DEVICE_PFN(vkGetImageMemoryRequirements)
3085     LOAD_DEVICE_PFN(vkGetSwapchainImagesKHR)
3086     LOAD_DEVICE_PFN(vkQueuePresentKHR)
3087     LOAD_DEVICE_PFN(vkQueueSubmit)
3088     LOAD_DEVICE_PFN(vkQueueWaitIdle)
3089     LOAD_DEVICE_PFN(vkResetFences)
3090     LOAD_DEVICE_PFN(vkWaitForFences)
3091 #undef LOAD_DEVICE_PFN
3092
3093     return TRUE;
3094 }
3095
3096 static inline struct d3d12_swapchain *d3d12_swapchain_from_wined3d_swapchain_state_parent(struct wined3d_swapchain_state_parent *parent)
3097 {
3098     return CONTAINING_RECORD(parent, struct d3d12_swapchain, state_parent);
3099 }
3100
3101 static void CDECL d3d12_swapchain_windowed_state_changed(struct wined3d_swapchain_state_parent *parent,
3102         BOOL windowed)
3103 {
3104     struct d3d12_swapchain *swapchain = d3d12_swapchain_from_wined3d_swapchain_state_parent(parent);
3105
3106     TRACE("parent %p, windowed %d.\n", parent, windowed);
3107
3108     if (windowed && swapchain->target)
3109     {
3110         IDXGIOutput_Release(swapchain->target);
3111         swapchain->target = NULL;
3112     }
3113 }
3114
3115 static const struct wined3d_swapchain_state_parent_ops d3d12_swapchain_state_parent_ops =
3116 {
3117     d3d12_swapchain_windowed_state_changed,
3118 };
3119
3120 static HRESULT d3d12_swapchain_init(struct d3d12_swapchain *swapchain, IWineDXGIFactory *factory,
3121         ID3D12Device *device, ID3D12CommandQueue *queue, HWND window,
3122         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc)
3123 {
3124     const struct dxgi_vk_funcs *vk_funcs = &swapchain->vk_funcs;
3125     struct wined3d_swapchain_desc wined3d_desc;
3126     VkWin32SurfaceCreateInfoKHR surface_desc;
3127     VkPhysicalDevice vk_physical_device;
3128     struct dxgi_factory *dxgi_factory;
3129     VkFenceCreateInfo fence_desc;
3130     uint32_t queue_family_index;
3131     VkSurfaceKHR vk_surface;
3132     VkInstance vk_instance;
3133     IDXGIOutput *output;
3134     VkBool32 supported;
3135     VkDevice vk_device;
3136     VkFence vk_fence;
3137     bool fullscreen;
3138     VkResult vr;
3139     HRESULT hr;
3140
3141     if (window == GetDesktopWindow())
3142     {
3143         WARN("D3D12 swapchain cannot be created on desktop window.\n");
3144         return E_ACCESSDENIED;
3145     }
3146
3147     swapchain->IDXGISwapChain4_iface.lpVtbl = &d3d12_swapchain_vtbl;
3148     swapchain->state_parent.ops = &d3d12_swapchain_state_parent_ops;
3149     swapchain->refcount = 1;
3150
3151     swapchain->window = window;
3152     swapchain->desc = *swapchain_desc;
3153     swapchain->backend_desc = *swapchain_desc;
3154     swapchain->fullscreen_desc = *fullscreen_desc;
3155
3156     swapchain->present_mode = VK_PRESENT_MODE_FIFO_KHR;
3157
3158     switch (swapchain_desc->SwapEffect)
3159     {
3160         case DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL:
3161         case DXGI_SWAP_EFFECT_FLIP_DISCARD:
3162             FIXME("Ignoring swap effect %#x.\n", swapchain_desc->SwapEffect);
3163             break;
3164         default:
3165             WARN("Invalid swap effect %#x.\n", swapchain_desc->SwapEffect);
3166             return DXGI_ERROR_INVALID_CALL;
3167     }
3168
3169     if (FAILED(hr = dxgi_get_output_from_window(factory, window, &output)))
3170     {
3171         WARN("Failed to get output from window %p, hr %#lx.\n", window, hr);
3172         return hr;
3173     }
3174
3175     hr = wined3d_swapchain_desc_from_dxgi(&wined3d_desc, output, window, swapchain_desc,
3176             fullscreen_desc);
3177     if (FAILED(hr))
3178     {
3179         IDXGIOutput_Release(output);
3180         return hr;
3181     }
3182
3183     fullscreen = !wined3d_desc.windowed;
3184     wined3d_desc.windowed = TRUE;
3185
3186     dxgi_factory = unsafe_impl_from_IDXGIFactory((IDXGIFactory *)factory);
3187     if (FAILED(hr = wined3d_swapchain_state_create(&wined3d_desc, window, dxgi_factory->wined3d,
3188             &swapchain->state_parent, &swapchain->state)))
3189     {
3190         IDXGIOutput_Release(output);
3191         return hr;
3192     }
3193
3194     wined3d_swapchain_state_get_size(swapchain->state, &swapchain->desc.Width, &swapchain->desc.Height);
3195
3196     if (fullscreen)
3197     {
3198         wined3d_desc.windowed = FALSE;
3199         hr = wined3d_swapchain_state_set_fullscreen(swapchain->state, &wined3d_desc, NULL);
3200         if (FAILED(hr))
3201         {
3202             wined3d_swapchain_state_destroy(swapchain->state);
3203             IDXGIOutput_Release(output);
3204             return hr;
3205         }
3206
3207         swapchain->target = output;
3208     }
3209     else
3210     {
3211         IDXGIOutput_Release(output);
3212     }
3213
3214     if (swapchain_desc->BufferUsage & ~(DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT))
3215         FIXME("Ignoring buffer usage %#x.\n", swapchain_desc->BufferUsage & ~(DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT));
3216     if (swapchain_desc->Scaling != DXGI_SCALING_STRETCH && swapchain_desc->Scaling != DXGI_SCALING_NONE)
3217         FIXME("Ignoring scaling %#x.\n", swapchain_desc->Scaling);
3218     if (swapchain_desc->AlphaMode && swapchain_desc->AlphaMode != DXGI_ALPHA_MODE_IGNORE)
3219         FIXME("Ignoring alpha mode %#x.\n", swapchain_desc->AlphaMode);
3220     if (swapchain_desc->Flags & ~(DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT))
3221         FIXME("Ignoring swapchain flags %#x.\n", swapchain_desc->Flags);
3222
3223     if (fullscreen_desc->RefreshRate.Numerator || fullscreen_desc->RefreshRate.Denominator)
3224         FIXME("Ignoring refresh rate.\n");
3225     if (fullscreen_desc->ScanlineOrdering)
3226         FIXME("Unhandled scanline ordering %#x.\n", fullscreen_desc->ScanlineOrdering);
3227     if (fullscreen_desc->Scaling)
3228         FIXME("Unhandled mode scaling %#x.\n", fullscreen_desc->Scaling);
3229
3230     vk_instance = vkd3d_instance_get_vk_instance(vkd3d_instance_from_device(device));
3231     vk_physical_device = vkd3d_get_vk_physical_device(device);
3232     vk_device = vkd3d_get_vk_device(device);
3233
3234     swapchain->vk_instance = vk_instance;
3235     swapchain->vk_device = vk_device;
3236     swapchain->vk_physical_device = vk_physical_device;
3237
3238     if (!init_vk_funcs(&swapchain->vk_funcs, vk_instance, vk_device))
3239     {
3240         wined3d_swapchain_state_destroy(swapchain->state);
3241         return E_FAIL;
3242     }
3243
3244     wined3d_private_store_init(&swapchain->private_store);
3245
3246     InitializeCriticalSection(&swapchain->worker_cs);
3247     InitializeConditionVariable(&swapchain->worker_cv);
3248     swapchain->worker_running = true;
3249     list_init(&swapchain->worker_ops);
3250
3251     surface_desc.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
3252     surface_desc.pNext = NULL;
3253     surface_desc.flags = 0;
3254     surface_desc.hinstance = GetModuleHandleA("dxgi.dll");
3255     surface_desc.hwnd = window;
3256     if ((vr = vk_funcs->p_vkCreateWin32SurfaceKHR(vk_instance, &surface_desc, NULL, &vk_surface)) < 0)
3257     {
3258         WARN("Failed to create Vulkan surface, vr %d.\n", vr);
3259         d3d12_swapchain_destroy(swapchain);
3260         return hresult_from_vk_result(vr);
3261     }
3262     swapchain->vk_surface = vk_surface;
3263
3264     queue_family_index = vkd3d_get_vk_queue_family_index(queue);
3265     if ((vr = vk_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(vk_physical_device,
3266             queue_family_index, vk_surface, &supported)) < 0 || !supported)
3267     {
3268         FIXME("Queue family does not support presentation, vr %d.\n", vr);
3269         d3d12_swapchain_destroy(swapchain);
3270         return DXGI_ERROR_UNSUPPORTED;
3271     }
3272
3273     ID3D12CommandQueue_AddRef(swapchain->command_queue = queue);
3274     ID3D12Device_AddRef(swapchain->device = device);
3275
3276     if (FAILED(hr = d3d12_swapchain_create_d3d12_resources(swapchain)))
3277     {
3278         d3d12_swapchain_destroy(swapchain);
3279         return hr;
3280     }
3281
3282     if (FAILED(hr = d3d12_swapchain_create_vulkan_resources(swapchain)))
3283     {
3284         d3d12_swapchain_destroy(swapchain);
3285         return hr;
3286     }
3287
3288     fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
3289     fence_desc.pNext = NULL;
3290     fence_desc.flags = 0;
3291     if ((vr = vk_funcs->p_vkCreateFence(vk_device, &fence_desc, NULL, &vk_fence)) < 0)
3292     {
3293         WARN("Failed to create Vulkan fence, vr %d.\n", vr);
3294         d3d12_swapchain_destroy(swapchain);
3295         return hresult_from_vk_result(vr);
3296     }
3297     swapchain->vk_fence = vk_fence;
3298
3299     swapchain->current_buffer_index = 0;
3300
3301     if (swapchain_desc->Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)
3302     {
3303         swapchain->frame_latency = 1;
3304
3305         if (FAILED(hr = ID3D12Device_CreateFence(device, DXGI_MAX_SWAP_CHAIN_BUFFERS,
3306                 0, &IID_ID3D12Fence, (void **)&swapchain->frame_latency_fence)))
3307         {
3308             WARN("Failed to create frame latency fence, hr %#lx.\n", hr);
3309             d3d12_swapchain_destroy(swapchain);
3310             return hr;
3311         }
3312
3313         if (!(swapchain->frame_latency_event = CreateEventW(NULL, FALSE, TRUE, NULL)))
3314         {
3315             hr = HRESULT_FROM_WIN32(GetLastError());
3316             WARN("Failed to create frame latency event, hr %#lx.\n", hr);
3317             d3d12_swapchain_destroy(swapchain);
3318             return hr;
3319         }
3320     }
3321
3322     if (FAILED(hr = ID3D12Device_CreateFence(device, 0, 0,
3323             &IID_ID3D12Fence, (void **)&swapchain->present_fence)))
3324     {
3325         WARN("Failed to create present fence, hr %#lx.\n", hr);
3326         d3d12_swapchain_destroy(swapchain);
3327         return hr;
3328     }
3329
3330     IWineDXGIFactory_AddRef(swapchain->factory = factory);
3331
3332     if (!(swapchain->worker_thread = CreateThread(NULL, 0, d3d12_swapchain_worker_proc, swapchain, 0, NULL)))
3333     {
3334         hr = HRESULT_FROM_WIN32(GetLastError());
3335         WARN("Failed to create worker thread, hr %#lx.\n", hr);
3336         d3d12_swapchain_destroy(swapchain);
3337         return hr;
3338     }
3339
3340     return S_OK;
3341 }
3342
3343 HRESULT d3d12_swapchain_create(IWineDXGIFactory *factory, ID3D12CommandQueue *queue, HWND window,
3344         const DXGI_SWAP_CHAIN_DESC1 *swapchain_desc, const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc,
3345         IDXGISwapChain1 **swapchain)
3346 {
3347     DXGI_SWAP_CHAIN_FULLSCREEN_DESC default_fullscreen_desc;
3348     struct D3D12_COMMAND_QUEUE_DESC queue_desc;
3349     struct d3d12_swapchain *object;
3350     ID3D12Device *device;
3351     HRESULT hr;
3352
3353     if (swapchain_desc->Format == DXGI_FORMAT_UNKNOWN)
3354         return DXGI_ERROR_INVALID_CALL;
3355
3356     queue_desc = ID3D12CommandQueue_GetDesc(queue);
3357     if (queue_desc.Type != D3D12_COMMAND_LIST_TYPE_DIRECT)
3358         return DXGI_ERROR_INVALID_CALL;
3359
3360     if (!fullscreen_desc)
3361     {
3362         memset(&default_fullscreen_desc, 0, sizeof(default_fullscreen_desc));
3363         default_fullscreen_desc.Windowed = TRUE;
3364         fullscreen_desc = &default_fullscreen_desc;
3365     }
3366
3367     if (!(object = calloc(1, sizeof(*object))))
3368         return E_OUTOFMEMORY;
3369
3370     if (FAILED(hr = ID3D12CommandQueue_GetDevice(queue, &IID_ID3D12Device, (void **)&device)))
3371     {
3372         ERR("Failed to get d3d12 device, hr %#lx.\n", hr);
3373         free(object);
3374         return hr;
3375     }
3376
3377     hr = d3d12_swapchain_init(object, factory, device, queue, window, swapchain_desc, fullscreen_desc);
3378     ID3D12Device_Release(device);
3379     if (FAILED(hr))
3380     {
3381         free(object);
3382         return hr;
3383     }
3384
3385     TRACE("Created swapchain %p.\n", object);
3386
3387     *swapchain = (IDXGISwapChain1 *)&object->IDXGISwapChain4_iface;
3388
3389     return S_OK;
3390 }