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