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 "config.h"
  21 #include "wine/port.h"
  22
  23 #include "dxgi_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(dxgi);
  26
  27 static inline struct dxgi_swapchain *impl_from_IDXGISwapChain1(IDXGISwapChain1 *iface)
  28 {
  29     return CONTAINING_RECORD(iface, struct dxgi_swapchain, IDXGISwapChain1_iface);
  30 }
  31
  32 /* IUnknown methods */
  33
  34 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_QueryInterface(IDXGISwapChain1 *iface, REFIID riid, void **object)
  35 {
  36     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
  37
  38     if (IsEqualGUID(riid, &IID_IUnknown)
  39             || IsEqualGUID(riid, &IID_IDXGIObject)
  40             || IsEqualGUID(riid, &IID_IDXGIDeviceSubObject)
  41             || IsEqualGUID(riid, &IID_IDXGISwapChain)
  42             || IsEqualGUID(riid, &IID_IDXGISwapChain1))
  43     {
  44         IUnknown_AddRef(iface);
  45         *object = iface;
  46         return S_OK;
  47     }
  48
  49     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  50
  51     *object = NULL;
  52     return E_NOINTERFACE;
  53 }
  54
  55 static ULONG STDMETHODCALLTYPE dxgi_swapchain_AddRef(IDXGISwapChain1 *iface)
  56 {
  57     struct dxgi_swapchain *This = impl_from_IDXGISwapChain1(iface);
  58     ULONG refcount = InterlockedIncrement(&This->refcount);
  59
  60     TRACE("%p increasing refcount to %u\n", This, refcount);
  61
  62     if (refcount == 1)
  63     {
  64         wined3d_mutex_lock();
  65         wined3d_swapchain_incref(This->wined3d_swapchain);
  66         wined3d_mutex_unlock();
  67     }
  68
  69     return refcount;
  70 }
  71
  72 static ULONG STDMETHODCALLTYPE dxgi_swapchain_Release(IDXGISwapChain1 *iface)
  73 {
  74     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
  75     ULONG refcount = InterlockedDecrement(&swapchain->refcount);
  76
  77     TRACE("%p decreasing refcount to %u.\n", swapchain, refcount);
  78
  79     if (!refcount)
  80     {
  81         IWineDXGIDevice *device = swapchain->device;
  82         if (swapchain->target)
  83         {
  84             WARN("Releasing fullscreen swapchain.\n");
  85             IDXGIOutput_Release(swapchain->target);
  86         }
  87         if (swapchain->factory)
  88             IDXGIFactory_Release(swapchain->factory);
  89         wined3d_mutex_lock();
  90         wined3d_swapchain_decref(swapchain->wined3d_swapchain);
  91         wined3d_mutex_unlock();
  92         if (device)
  93             IWineDXGIDevice_Release(device);
  94     }
  95
  96     return refcount;
  97 }
  98
  99 /* IDXGIObject methods */
 100
 101 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetPrivateData(IDXGISwapChain1 *iface,
 102         REFGUID guid, UINT data_size, const void *data)
 103 {
 104     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 105
 106     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 107
 108     return dxgi_set_private_data(&swapchain->private_store, guid, data_size, data);
 109 }
 110
 111 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetPrivateDataInterface(IDXGISwapChain1 *iface,
 112         REFGUID guid, const IUnknown *object)
 113 {
 114     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 115
 116     TRACE("iface %p, guid %s, object %p.\n", iface, debugstr_guid(guid), object);
 117
 118     return dxgi_set_private_data_interface(&swapchain->private_store, guid, object);
 119 }
 120
 121 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetPrivateData(IDXGISwapChain1 *iface,
 122         REFGUID guid, UINT *data_size, void *data)
 123 {
 124     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 125
 126     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 127
 128     return dxgi_get_private_data(&swapchain->private_store, guid, data_size, data);
 129 }
 130
 131 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetParent(IDXGISwapChain1 *iface, REFIID riid, void **parent)
 132 {
 133     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 134
 135     TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent);
 136
 137     if (!swapchain->factory)
 138     {
 139         ERR("Implicit swapchain does not store reference to parent.\n");
 140         *parent = NULL;
 141         return E_NOINTERFACE;
 142     }
 143
 144     return IDXGIFactory_QueryInterface(swapchain->factory, riid, parent);
 145 }
 146
 147 /* IDXGIDeviceSubObject methods */
 148
 149 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetDevice(IDXGISwapChain1 *iface, REFIID riid, void **device)
 150 {
 151     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 152
 153     TRACE("iface %p, riid %s, device %p.\n", iface, debugstr_guid(riid), device);
 154
 155     if (!swapchain->device)
 156     {
 157         ERR("Implicit swapchain does not store reference to device.\n");
 158         *device = NULL;
 159         return E_NOINTERFACE;
 160     }
 161
 162     return IWineDXGIDevice_QueryInterface(swapchain->device, riid, device);
 163 }
 164
 165 /* IDXGISwapChain1 methods */
 166
 167 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_Present(IDXGISwapChain1 *iface, UINT sync_interval, UINT flags)
 168 {
 169     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 170
 171     TRACE("iface %p, sync_interval %u, flags %#x.\n", iface, sync_interval, flags);
 172
 173     return IDXGISwapChain1_Present1(&swapchain->IDXGISwapChain1_iface, sync_interval, flags, NULL);
 174 }
 175
 176 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetBuffer(IDXGISwapChain1 *iface,
 177         UINT buffer_idx, REFIID riid, void **surface)
 178 {
 179     struct dxgi_swapchain *This = impl_from_IDXGISwapChain1(iface);
 180     struct wined3d_texture *texture;
 181     IUnknown *parent;
 182     HRESULT hr;
 183
 184     TRACE("iface %p, buffer_idx %u, riid %s, surface %p\n",
 185             iface, buffer_idx, debugstr_guid(riid), surface);
 186
 187     wined3d_mutex_lock();
 188
 189     if (!(texture = wined3d_swapchain_get_back_buffer(This->wined3d_swapchain, buffer_idx)))
 190     {
 191         wined3d_mutex_unlock();
 192         return DXGI_ERROR_INVALID_CALL;
 193     }
 194
 195     parent = wined3d_texture_get_parent(texture);
 196     hr = IUnknown_QueryInterface(parent, riid, surface);
 197     wined3d_mutex_unlock();
 198
 199     return hr;
 200 }
 201
 202 static HRESULT STDMETHODCALLTYPE DECLSPEC_HOTPATCH dxgi_swapchain_SetFullscreenState(IDXGISwapChain1 *iface,
 203         BOOL fullscreen, IDXGIOutput *target)
 204 {
 205     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 206     struct wined3d_swapchain_desc swapchain_desc;
 207     HRESULT hr;
 208
 209     TRACE("iface %p, fullscreen %#x, target %p.\n", iface, fullscreen, target);
 210
 211     if (!fullscreen && target)
 212     {
 213         WARN("Invalid call.\n");
 214         return DXGI_ERROR_INVALID_CALL;
 215     }
 216
 217     if (fullscreen)
 218     {
 219         if (target)
 220         {
 221             IDXGIOutput_AddRef(target);
 222         }
 223         else if (FAILED(hr = IDXGISwapChain1_GetContainingOutput(iface, &target)))
 224         {
 225             WARN("Failed to get default target output for swapchain, hr %#x.\n", hr);
 226             return hr;
 227         }
 228     }
 229
 230     wined3d_mutex_lock();
 231     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &swapchain_desc);
 232     swapchain_desc.windowed = !fullscreen;
 233     hr = wined3d_swapchain_set_fullscreen(swapchain->wined3d_swapchain, &swapchain_desc, NULL);
 234     wined3d_mutex_unlock();
 235
 236     if (SUCCEEDED(hr))
 237     {
 238         swapchain->fullscreen = fullscreen;
 239         if (swapchain->target)
 240             IDXGIOutput_Release(swapchain->target);
 241         swapchain->target = target;
 242     }
 243     else
 244     {
 245         IDXGIOutput_Release(target);
 246     }
 247
 248     return hr;
 249 }
 250
 251 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetFullscreenState(IDXGISwapChain1 *iface,
 252         BOOL *fullscreen, IDXGIOutput **target)
 253 {
 254     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 255
 256     TRACE("iface %p, fullscreen %p, target %p.\n", iface, fullscreen, target);
 257
 258     if (fullscreen)
 259         *fullscreen = swapchain->fullscreen;
 260
 261     if (target)
 262     {
 263         *target = swapchain->target;
 264         if (*target)
 265             IDXGIOutput_AddRef(*target);
 266     }
 267
 268     return S_OK;
 269 }
 270
 271 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetDesc(IDXGISwapChain1 *iface, DXGI_SWAP_CHAIN_DESC *desc)
 272 {
 273     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 274     struct wined3d_swapchain_desc wined3d_desc;
 275
 276     TRACE("iface %p, desc %p.\n", iface, desc);
 277
 278     if (!desc)
 279     {
 280         WARN("Invalid pointer.\n");
 281         return E_INVALIDARG;
 282     }
 283
 284     wined3d_mutex_lock();
 285     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 286     wined3d_mutex_unlock();
 287
 288     FIXME("Ignoring ScanlineOrdering, Scaling and SwapEffect.\n");
 289
 290     desc->BufferDesc.Width = wined3d_desc.backbuffer_width;
 291     desc->BufferDesc.Height = wined3d_desc.backbuffer_height;
 292     desc->BufferDesc.RefreshRate.Numerator = wined3d_desc.refresh_rate;
 293     desc->BufferDesc.RefreshRate.Denominator = 1;
 294     desc->BufferDesc.Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 295     desc->BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 296     desc->BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 297     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 298             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 299     desc->BufferUsage = dxgi_usage_from_wined3d_usage(wined3d_desc.backbuffer_usage);
 300     desc->BufferCount = wined3d_desc.backbuffer_count;
 301     desc->OutputWindow = wined3d_desc.device_window;
 302     desc->Windowed = wined3d_desc.windowed;
 303     desc->SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
 304     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 305
 306     return S_OK;
 307 }
 308
 309 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeBuffers(IDXGISwapChain1 *iface,
 310         UINT buffer_count, UINT width, UINT height, DXGI_FORMAT format, UINT flags)
 311 {
 312     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 313     struct wined3d_swapchain_desc wined3d_desc;
 314     struct wined3d_texture *texture;
 315     IUnknown *parent;
 316     unsigned int i;
 317     HRESULT hr;
 318
 319     TRACE("iface %p, buffer_count %u, width %u, height %u, format %s, flags %#x.\n",
 320             iface, buffer_count, width, height, debug_dxgi_format(format), flags);
 321
 322     if (flags)
 323         FIXME("Ignoring flags %#x.\n", flags);
 324
 325     wined3d_mutex_lock();
 326     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 327     for (i = 0; i < wined3d_desc.backbuffer_count; ++i)
 328     {
 329         texture = wined3d_swapchain_get_back_buffer(swapchain->wined3d_swapchain, i);
 330         parent = wined3d_texture_get_parent(texture);
 331         IUnknown_AddRef(parent);
 332         if (IUnknown_Release(parent))
 333         {
 334             wined3d_mutex_unlock();
 335             return DXGI_ERROR_INVALID_CALL;
 336         }
 337     }
 338     if (format != DXGI_FORMAT_UNKNOWN)
 339         wined3d_desc.backbuffer_format = wined3dformat_from_dxgi_format(format);
 340     hr = wined3d_swapchain_resize_buffers(swapchain->wined3d_swapchain, buffer_count, width, height,
 341             wined3d_desc.backbuffer_format, wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 342     wined3d_mutex_unlock();
 343
 344     return hr;
 345 }
 346
 347 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_ResizeTarget(IDXGISwapChain1 *iface,
 348         const DXGI_MODE_DESC *target_mode_desc)
 349 {
 350     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 351     struct wined3d_display_mode mode;
 352     HRESULT hr;
 353
 354     TRACE("iface %p, target_mode_desc %p.\n", iface, target_mode_desc);
 355
 356     if (!target_mode_desc)
 357     {
 358         WARN("Invalid pointer.\n");
 359         return DXGI_ERROR_INVALID_CALL;
 360     }
 361
 362     TRACE("Mode: %s.\n", debug_dxgi_mode(target_mode_desc));
 363
 364     if (target_mode_desc->Scaling)
 365         FIXME("Ignoring scaling %#x.\n", target_mode_desc->Scaling);
 366
 367     wined3d_display_mode_from_dxgi(&mode, target_mode_desc);
 368
 369     wined3d_mutex_lock();
 370     hr = wined3d_swapchain_resize_target(swapchain->wined3d_swapchain, &mode);
 371     wined3d_mutex_unlock();
 372
 373     return hr;
 374 }
 375
 376 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetContainingOutput(IDXGISwapChain1 *iface, IDXGIOutput **output)
 377 {
 378     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 379     IDXGIAdapter *adapter;
 380     IDXGIDevice *device;
 381     HRESULT hr;
 382
 383     TRACE("iface %p, output %p.\n", iface, output);
 384
 385     if (swapchain->target)
 386     {
 387         IDXGIOutput_AddRef(*output = swapchain->target);
 388         return S_OK;
 389     }
 390
 391     if (FAILED(hr = dxgi_swapchain_GetDevice(iface, &IID_IDXGIDevice, (void **)&device)))
 392         return hr;
 393
 394     hr = IDXGIDevice_GetAdapter(device, &adapter);
 395     IDXGIDevice_Release(device);
 396     if (FAILED(hr))
 397     {
 398         WARN("GetAdapter failed, hr %#x.\n", hr);
 399         return hr;
 400     }
 401
 402     if (SUCCEEDED(IDXGIAdapter_EnumOutputs(adapter, 1, output)))
 403     {
 404         FIXME("Adapter has got multiple outputs, returning the first one.\n");
 405         IDXGIOutput_Release(*output);
 406     }
 407
 408     hr = IDXGIAdapter_EnumOutputs(adapter, 0, output);
 409     IDXGIAdapter_Release(adapter);
 410     return hr;
 411 }
 412
 413 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetFrameStatistics(IDXGISwapChain1 *iface,
 414         DXGI_FRAME_STATISTICS *stats)
 415 {
 416     FIXME("iface %p, stats %p stub!\n", iface, stats);
 417
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetLastPresentCount(IDXGISwapChain1 *iface,
 422         UINT *last_present_count)
 423 {
 424     FIXME("iface %p, last_present_count %p stub!\n", iface, last_present_count);
 425
 426     return E_NOTIMPL;
 427 }
 428
 429 /* IDXGISwapChain1 methods */
 430
 431 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetDesc1(IDXGISwapChain1 *iface, DXGI_SWAP_CHAIN_DESC1 *desc)
 432 {
 433     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 434     struct wined3d_swapchain_desc wined3d_desc;
 435
 436     TRACE("iface %p, desc %p.\n", iface, desc);
 437
 438     if (!desc)
 439     {
 440         WARN("Invalid pointer.\n");
 441         return E_INVALIDARG;
 442     }
 443
 444     wined3d_mutex_lock();
 445     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 446     wined3d_mutex_unlock();
 447
 448     FIXME("Ignoring Stereo, Scaling, SwapEffect and AlphaMode.\n");
 449
 450     desc->Width = wined3d_desc.backbuffer_width;
 451     desc->Height = wined3d_desc.backbuffer_height;
 452     desc->Format = dxgi_format_from_wined3dformat(wined3d_desc.backbuffer_format);
 453     desc->Stereo = FALSE;
 454     dxgi_sample_desc_from_wined3d(&desc->SampleDesc,
 455             wined3d_desc.multisample_type, wined3d_desc.multisample_quality);
 456     desc->BufferUsage = dxgi_usage_from_wined3d_usage(wined3d_desc.backbuffer_usage);
 457     desc->BufferCount = wined3d_desc.backbuffer_count;
 458     desc->Scaling = DXGI_SCALING_STRETCH;
 459     desc->SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
 460     desc->AlphaMode = DXGI_ALPHA_MODE_IGNORE;
 461     desc->Flags = dxgi_swapchain_flags_from_wined3d(wined3d_desc.flags);
 462
 463     return S_OK;
 464 }
 465
 466 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetFullscreenDesc(IDXGISwapChain1 *iface,
 467         DXGI_SWAP_CHAIN_FULLSCREEN_DESC *desc)
 468 {
 469     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 470     struct wined3d_swapchain_desc wined3d_desc;
 471
 472     TRACE("iface %p, desc %p.\n", iface, desc);
 473
 474     if (!desc)
 475     {
 476         WARN("Invalid pointer.\n");
 477         return E_INVALIDARG;
 478     }
 479
 480     wined3d_mutex_lock();
 481     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 482     wined3d_mutex_unlock();
 483
 484     FIXME("Ignoring ScanlineOrdering and Scaling.\n");
 485
 486     desc->RefreshRate.Numerator = wined3d_desc.refresh_rate;
 487     desc->RefreshRate.Denominator = 1;
 488     desc->ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
 489     desc->Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
 490     desc->Windowed = wined3d_desc.windowed;
 491
 492     return S_OK;
 493 }
 494
 495 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetHwnd(IDXGISwapChain1 *iface, HWND *hwnd)
 496 {
 497     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 498     struct wined3d_swapchain_desc wined3d_desc;
 499
 500     TRACE("iface %p, hwnd %p.\n", iface, hwnd);
 501
 502     if (!hwnd)
 503     {
 504         WARN("Invalid pointer.\n");
 505         return DXGI_ERROR_INVALID_CALL;
 506     }
 507
 508     wined3d_mutex_lock();
 509     wined3d_swapchain_get_desc(swapchain->wined3d_swapchain, &wined3d_desc);
 510     wined3d_mutex_unlock();
 511
 512     *hwnd = wined3d_desc.device_window;
 513     return S_OK;
 514 }
 515
 516 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetCoreWindow(IDXGISwapChain1 *iface,
 517         REFIID iid, void **core_window)
 518 {
 519     FIXME("iface %p, iid %s, core_window %p stub!\n", iface, debugstr_guid(iid), core_window);
 520
 521     if (core_window)
 522         *core_window = NULL;
 523
 524     return DXGI_ERROR_INVALID_CALL;
 525 }
 526
 527 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_Present1(IDXGISwapChain1 *iface,
 528         UINT sync_interval, UINT flags, const DXGI_PRESENT_PARAMETERS *present_parameters)
 529 {
 530     struct dxgi_swapchain *swapchain = impl_from_IDXGISwapChain1(iface);
 531     HRESULT hr;
 532
 533     TRACE("iface %p, sync_interval %u, flags %#x, present_parameters %p.\n",
 534             iface, sync_interval, flags, present_parameters);
 535
 536     if (flags & ~DXGI_PRESENT_TEST)
 537         FIXME("Unimplemented flags %#x.\n", flags);
 538     if (flags & DXGI_PRESENT_TEST)
 539     {
 540         WARN("Returning S_OK for DXGI_PRESENT_TEST.\n");
 541         return S_OK;
 542     }
 543
 544     if (sync_interval)
 545         FIXME("Unimplemented sync interval %u.\n", sync_interval);
 546     if (present_parameters)
 547         FIXME("Ignored present parameters %p.\n", present_parameters);
 548
 549     wined3d_mutex_lock();
 550     hr = wined3d_swapchain_present(swapchain->wined3d_swapchain, NULL, NULL, NULL, 0);
 551     wined3d_mutex_unlock();
 552
 553     return hr;
 554 }
 555
 556 static BOOL STDMETHODCALLTYPE dxgi_swapchain_IsTemporaryMonoSupported(IDXGISwapChain1 *iface)
 557 {
 558     FIXME("iface %p stub!\n", iface);
 559
 560     return FALSE;
 561 }
 562
 563 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetRestrictToOutput(IDXGISwapChain1 *iface, IDXGIOutput **output)
 564 {
 565     FIXME("iface %p, output %p stub!\n", iface, output);
 566
 567     if (!output)
 568     {
 569         WARN("Invalid pointer.\n");
 570         return E_INVALIDARG;
 571     }
 572
 573     *output = NULL;
 574     return E_NOTIMPL;
 575 }
 576
 577 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetBackgroundColor(IDXGISwapChain1 *iface, const DXGI_RGBA *color)
 578 {
 579     FIXME("iface %p, color %p stub!\n", iface, color);
 580
 581     return E_NOTIMPL;
 582 }
 583
 584 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetBackgroundColor(IDXGISwapChain1 *iface, DXGI_RGBA *color)
 585 {
 586     FIXME("iface %p, color %p stub!\n", iface, color);
 587
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_SetRotation(IDXGISwapChain1 *iface, DXGI_MODE_ROTATION rotation)
 592 {
 593     FIXME("iface %p, rotation %#x stub!\n", iface, rotation);
 594
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT STDMETHODCALLTYPE dxgi_swapchain_GetRotation(IDXGISwapChain1 *iface, DXGI_MODE_ROTATION *rotation)
 599 {
 600     FIXME("iface %p, rotation %p stub!\n", iface, rotation);
 601
 602     return E_NOTIMPL;
 603 }
 604
 605 static const struct IDXGISwapChain1Vtbl dxgi_swapchain_vtbl =
 606 {
 607     /* IUnknown methods */
 608     dxgi_swapchain_QueryInterface,
 609     dxgi_swapchain_AddRef,
 610     dxgi_swapchain_Release,
 611     /* IDXGIObject methods */
 612     dxgi_swapchain_SetPrivateData,
 613     dxgi_swapchain_SetPrivateDataInterface,
 614     dxgi_swapchain_GetPrivateData,
 615     dxgi_swapchain_GetParent,
 616     /* IDXGIDeviceSubObject methods */
 617     dxgi_swapchain_GetDevice,
 618     /* IDXGISwapChain methods */
 619     dxgi_swapchain_Present,
 620     dxgi_swapchain_GetBuffer,
 621     dxgi_swapchain_SetFullscreenState,
 622     dxgi_swapchain_GetFullscreenState,
 623     dxgi_swapchain_GetDesc,
 624     dxgi_swapchain_ResizeBuffers,
 625     dxgi_swapchain_ResizeTarget,
 626     dxgi_swapchain_GetContainingOutput,
 627     dxgi_swapchain_GetFrameStatistics,
 628     dxgi_swapchain_GetLastPresentCount,
 629     /* IDXGISwapChain1 methods */
 630     dxgi_swapchain_GetDesc1,
 631     dxgi_swapchain_GetFullscreenDesc,
 632     dxgi_swapchain_GetHwnd,
 633     dxgi_swapchain_GetCoreWindow,
 634     dxgi_swapchain_Present1,
 635     dxgi_swapchain_IsTemporaryMonoSupported,
 636     dxgi_swapchain_GetRestrictToOutput,
 637     dxgi_swapchain_SetBackgroundColor,
 638     dxgi_swapchain_GetBackgroundColor,
 639     dxgi_swapchain_SetRotation,
 640     dxgi_swapchain_GetRotation,
 641 };
 642
 643 static void STDMETHODCALLTYPE dxgi_swapchain_wined3d_object_released(void *parent)
 644 {
 645     struct dxgi_swapchain *swapchain = parent;
 646
 647     wined3d_private_store_cleanup(&swapchain->private_store);
 648     heap_free(parent);
 649 }
 650
 651 static const struct wined3d_parent_ops dxgi_swapchain_wined3d_parent_ops =
 652 {
 653     dxgi_swapchain_wined3d_object_released,
 654 };
 655
 656 HRESULT dxgi_swapchain_init(struct dxgi_swapchain *swapchain, struct dxgi_device *device,
 657         struct wined3d_swapchain_desc *desc, BOOL implicit)
 658 {
 659     HRESULT hr;
 660
 661     /**
 662      * A reference to the implicit swapchain is held by the wined3d device.
 663      * In order to avoid circular references we do not keep a reference
 664      * to the device in the implicit swapchain.
 665      */
 666     if (!implicit)
 667     {
 668         if (FAILED(hr = IWineDXGIAdapter_GetParent(device->adapter, &IID_IDXGIFactory,
 669                 (void **)&swapchain->factory)))
 670         {
 671             WARN("Failed to get adapter parent, hr %#x.\n", hr);
 672             return hr;
 673         }
 674         IWineDXGIDevice_AddRef(swapchain->device = &device->IWineDXGIDevice_iface);
 675     }
 676     else
 677     {
 678         swapchain->device = NULL;
 679         swapchain->factory = NULL;
 680     }
 681
 682     swapchain->IDXGISwapChain1_iface.lpVtbl = &dxgi_swapchain_vtbl;
 683     swapchain->refcount = 1;
 684     wined3d_mutex_lock();
 685     wined3d_private_store_init(&swapchain->private_store);
 686
 687     if (!desc->windowed && (!desc->backbuffer_width || !desc->backbuffer_height))
 688         FIXME("Fullscreen swapchain with back buffer width/height equal to 0 not supported properly.\n");
 689
 690     swapchain->fullscreen = !desc->windowed;
 691     desc->windowed = TRUE;
 692     if (FAILED(hr = wined3d_swapchain_create(device->wined3d_device, desc, swapchain,
 693             &dxgi_swapchain_wined3d_parent_ops, &swapchain->wined3d_swapchain)))
 694     {
 695         WARN("Failed to create wined3d swapchain, hr %#x.\n", hr);
 696         goto cleanup;
 697     }
 698
 699     swapchain->target = NULL;
 700     if (swapchain->fullscreen)
 701     {
 702         desc->windowed = FALSE;
 703         if (FAILED(hr = wined3d_swapchain_set_fullscreen(swapchain->wined3d_swapchain,
 704                 desc, NULL)))
 705         {
 706             WARN("Failed to set fullscreen state, hr %#x.\n", hr);
 707             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 708             goto cleanup;
 709         }
 710
 711         if (FAILED(hr = IDXGISwapChain1_GetContainingOutput(&swapchain->IDXGISwapChain1_iface,
 712                 &swapchain->target)))
 713         {
 714             WARN("Failed to get target output for fullscreen swapchain, hr %#x.\n", hr);
 715             wined3d_swapchain_decref(swapchain->wined3d_swapchain);
 716             goto cleanup;
 717         }
 718     }
 719     wined3d_mutex_unlock();
 720
 721     return S_OK;
 722
 723 cleanup:
 724     wined3d_private_store_cleanup(&swapchain->private_store);
 725     wined3d_mutex_unlock();
 726     if (swapchain->factory)
 727         IDXGIFactory_Release(swapchain->factory);
 728     if (swapchain->device)
 729         IWineDXGIDevice_Release(swapchain->device);
 730     return hr;
 731 }