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