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 /* IUnknown methods */
28
29 static HRESULT STDMETHODCALLTYPE dxgi_device_QueryInterface(IWineDXGIDevice *iface, REFIID riid, void **object)
30 {
31 struct dxgi_device *This = (struct dxgi_device *)iface;
32
33 TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
34
35 if (IsEqualGUID(riid, &IID_IUnknown)
36 || IsEqualGUID(riid, &IID_IDXGIObject)
37 || IsEqualGUID(riid, &IID_IDXGIDevice)
38 || IsEqualGUID(riid, &IID_IWineDXGIDevice))
39 {
40 IUnknown_AddRef(iface);
41 *object = iface;
42 return S_OK;
43 }
44
45 if (This->child_layer)
46 {
47 TRACE("forwarding to child layer %p\n", This->child_layer);
48 return IUnknown_QueryInterface(This->child_layer, riid, object);
49 }
50
51 WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
52
53 *object = NULL;
54 return E_NOINTERFACE;
55 }
56
57 static ULONG STDMETHODCALLTYPE dxgi_device_AddRef(IWineDXGIDevice *iface)
58 {
59 struct dxgi_device *This = (struct dxgi_device *)iface;
60 ULONG refcount = InterlockedIncrement(&This->refcount);
61
62 TRACE("%p increasing refcount to %u\n", This, refcount);
63
64 return refcount;
65 }
66
67 static ULONG STDMETHODCALLTYPE dxgi_device_Release(IWineDXGIDevice *iface)
68 {
69 struct dxgi_device *This = (struct dxgi_device *)iface;
70 ULONG refcount = InterlockedDecrement(&This->refcount);
71
72 TRACE("%p decreasing refcount to %u\n", This, refcount);
73
74 if (!refcount)
75 {
76 if (This->child_layer) IUnknown_Release(This->child_layer);
77 EnterCriticalSection(&dxgi_cs);
78 IWineD3DDevice_Release(This->wined3d_device);
79 LeaveCriticalSection(&dxgi_cs);
80 IWineDXGIFactory_Release(This->factory);
81 HeapFree(GetProcessHeap(), 0, This);
82 }
83
84 return refcount;
85 }
86
87 /* IDXGIObject methods */
88
89 static HRESULT STDMETHODCALLTYPE dxgi_device_SetPrivateData(IWineDXGIDevice *iface,
90 REFGUID guid, UINT data_size, const void *data)
91 {
92 FIXME("iface %p, guid %s, data_size %u, data %p stub!\n", iface, debugstr_guid(guid), data_size, data);
93
94 return E_NOTIMPL;
95 }
96
97 static HRESULT STDMETHODCALLTYPE dxgi_device_SetPrivateDataInterface(IWineDXGIDevice *iface,
98 REFGUID guid, const IUnknown *object)
99 {
100 FIXME("iface %p, guid %s, object %p stub!\n", iface, debugstr_guid(guid), object);
101
102 return E_NOTIMPL;
103 }
104
105 static HRESULT STDMETHODCALLTYPE dxgi_device_GetPrivateData(IWineDXGIDevice *iface,
106 REFGUID guid, UINT *data_size, void *data)
107 {
108 FIXME("iface %p, guid %s, data_size %p, data %p stub!\n", iface, debugstr_guid(guid), data_size, data);
109
110 return E_NOTIMPL;
111 }
112
113 static HRESULT STDMETHODCALLTYPE dxgi_device_GetParent(IWineDXGIDevice *iface, REFIID riid, void **parent)
114 {
115 IDXGIAdapter *adapter;
116 HRESULT hr;
117
118 TRACE("iface %p, riid %s, parent %p.\n", iface, debugstr_guid(riid), parent);
119
120 hr = IDXGIDevice_GetAdapter(iface, &adapter);
121 if (FAILED(hr))
122 {
123 ERR("Failed to get adapter, hr %#x.\n", hr);
124 return hr;
125 }
126
127 hr = IDXGIAdapter_QueryInterface(adapter, riid, parent);
128 IDXGIAdapter_Release(adapter);
129
130 return hr;
131 }
132
133 /* IDXGIDevice methods */
134
135 static HRESULT STDMETHODCALLTYPE dxgi_device_GetAdapter(IWineDXGIDevice *iface, IDXGIAdapter **adapter)
136 {
137 struct dxgi_device *This = (struct dxgi_device *)iface;
138 WINED3DDEVICE_CREATION_PARAMETERS create_parameters;
139 HRESULT hr;
140
141 TRACE("iface %p, adapter %p\n", iface, adapter);
142
143 EnterCriticalSection(&dxgi_cs);
144
145 hr = IWineD3DDevice_GetCreationParameters(This->wined3d_device, &create_parameters);
146 if (FAILED(hr))
147 {
148 LeaveCriticalSection(&dxgi_cs);
149 return hr;
150 }
151
152 LeaveCriticalSection(&dxgi_cs);
153
154 return IWineDXGIFactory_EnumAdapters(This->factory, create_parameters.AdapterOrdinal, adapter);
155 }
156
157 static HRESULT STDMETHODCALLTYPE dxgi_device_CreateSurface(IWineDXGIDevice *iface,
158 const DXGI_SURFACE_DESC *desc, UINT surface_count, DXGI_USAGE usage,
159 const DXGI_SHARED_RESOURCE *shared_resource, IDXGISurface **surface)
160 {
161 IWineD3DDeviceParent *device_parent;
162 HRESULT hr;
163 UINT i;
164 UINT j;
165
166 TRACE("iface %p, desc %p, surface_count %u, usage %#x, shared_resource %p, surface %p\n",
167 iface, desc, surface_count, usage, shared_resource, surface);
168
169 hr = IWineDXGIDevice_QueryInterface(iface, &IID_IWineD3DDeviceParent, (void **)&device_parent);
170 if (FAILED(hr))
171 {
172 ERR("Device should implement IWineD3DDeviceParent\n");
173 return E_FAIL;
174 }
175
176 FIXME("Implement DXGI<->wined3d usage conversion\n");
177
178 memset(surface, 0, surface_count * sizeof(*surface));
179 for (i = 0; i < surface_count; ++i)
180 {
181 IWineD3DSurface *wined3d_surface;
182 IUnknown *parent;
183
184 hr = IWineD3DDeviceParent_CreateSurface(device_parent, NULL, desc->Width, desc->Height,
185 wined3dformat_from_dxgi_format(desc->Format), usage, WINED3DPOOL_DEFAULT, 0,
186 WINED3DCUBEMAP_FACE_POSITIVE_X, &wined3d_surface);
187 if (FAILED(hr))
188 {
189 ERR("CreateSurface failed, returning %#x\n", hr);
190 goto fail;
191 }
192
193 hr = IWineD3DSurface_GetParent(wined3d_surface, &parent);
194 IWineD3DSurface_Release(wined3d_surface);
195 if (FAILED(hr))
196 {
197 ERR("GetParent failed, returning %#x\n", hr);
198 goto fail;
199 }
200
201 hr = IUnknown_QueryInterface(parent, &IID_IDXGISurface, (void **)&surface[i]);
202 IUnknown_Release(parent);
203 if (FAILED(hr))
204 {
205 ERR("Surface should implement IDXGISurface\n");
206 goto fail;
207 }
208
209 TRACE("Created IDXGISurface %p (%u/%u)\n", surface[i], i + 1, surface_count);
210 }
211 IWineD3DDeviceParent_Release(device_parent);
212
213 return S_OK;
214
215 fail:
216 for (j = 0; j < i; ++j)
217 {
218 IDXGISurface_Release(surface[i]);
219 }
220 IWineD3DDeviceParent_Release(device_parent);
221 return hr;
222 }
223
224 static HRESULT STDMETHODCALLTYPE dxgi_device_QueryResourceResidency(IWineDXGIDevice *iface,
225 IUnknown *const *resources, DXGI_RESIDENCY *residency, UINT resource_count)
226 {
227 FIXME("iface %p, resources %p, residency %p, resource_count %u stub!\n",
228 iface, resources, residency, resource_count);
229
230 return E_NOTIMPL;
231 }
232
233 static HRESULT STDMETHODCALLTYPE dxgi_device_SetGPUThreadPriority(IWineDXGIDevice *iface, INT priority)
234 {
235 FIXME("iface %p, priority %d stub!\n", iface, priority);
236
237 return E_NOTIMPL;
238 }
239
240 static HRESULT STDMETHODCALLTYPE dxgi_device_GetGPUThreadPriority(IWineDXGIDevice *iface, INT *priority)
241 {
242 FIXME("iface %p, priority %p stub!\n", iface, priority);
243
244 return E_NOTIMPL;
245 }
246
247 /* IWineDXGIDevice methods */
248
249 static IWineD3DDevice * STDMETHODCALLTYPE dxgi_device_get_wined3d_device(IWineDXGIDevice *iface)
250 {
251 struct dxgi_device *This = (struct dxgi_device *)iface;
252
253 TRACE("iface %p\n", iface);
254
255 EnterCriticalSection(&dxgi_cs);
256 IWineD3DDevice_AddRef(This->wined3d_device);
257 LeaveCriticalSection(&dxgi_cs);
258 return This->wined3d_device;
259 }
260
261 static HRESULT STDMETHODCALLTYPE dxgi_device_create_surface(IWineDXGIDevice *iface, const DXGI_SURFACE_DESC *desc,
262 DXGI_USAGE usage, const DXGI_SHARED_RESOURCE *shared_resource, IUnknown *outer, void **surface)
263 {
264 struct dxgi_surface *object;
265 HRESULT hr;
266
267 FIXME("iface %p, desc %p, usage %#x, shared_resource %p, outer %p, surface %p partial stub!\n",
268 iface, desc, usage, shared_resource, outer, surface);
269
270 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
271 if (!object)
272 {
273 ERR("Failed to allocate DXGI surface object memory\n");
274 return E_OUTOFMEMORY;
275 }
276
277 hr = dxgi_surface_init(object, (IDXGIDevice *)iface, outer);
278 if (FAILED(hr))
279 {
280 WARN("Failed to initialize surface, hr %#x.\n", hr);
281 HeapFree(GetProcessHeap(), 0, object);
282 return hr;
283 }
284
285 TRACE("Created IDXGISurface %p\n", object);
286 *surface = outer ? (void *)&object->inner_unknown_vtbl : object;
287
288 return S_OK;
289 }
290
291 static HRESULT STDMETHODCALLTYPE dxgi_device_create_swapchain(IWineDXGIDevice *iface,
292 WINED3DPRESENT_PARAMETERS *present_parameters, IWineD3DSwapChain **wined3d_swapchain)
293 {
294 struct dxgi_swapchain *object;
295 HRESULT hr;
296
297 TRACE("iface %p, present_parameters %p, wined3d_swapchain %p.\n",
298 iface, present_parameters, wined3d_swapchain);
299
300 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
301 if (!object)
302 {
303 ERR("Failed to allocate DXGI swapchain object memory\n");
304 return E_OUTOFMEMORY;
305 }
306
307 hr = dxgi_swapchain_init(object, (struct dxgi_device *)iface, present_parameters);
308 if (FAILED(hr))
309 {
310 WARN("Failed to initialize swapchain, hr %#x.\n", hr);
311 HeapFree(GetProcessHeap(), 0, object);
312 return hr;
313 }
314
315 TRACE("Created IDXGISwapChain %p\n", object);
316 *wined3d_swapchain = object->wined3d_swapchain;
317
318 return S_OK;
319 }
320
321 static const struct IWineDXGIDeviceVtbl dxgi_device_vtbl =
322 {
323 /* IUnknown methods */
324 dxgi_device_QueryInterface,
325 dxgi_device_AddRef,
326 dxgi_device_Release,
327 /* IDXGIObject methods */
328 dxgi_device_SetPrivateData,
329 dxgi_device_SetPrivateDataInterface,
330 dxgi_device_GetPrivateData,
331 dxgi_device_GetParent,
332 /* IDXGIDevice methods */
333 dxgi_device_GetAdapter,
334 dxgi_device_CreateSurface,
335 dxgi_device_QueryResourceResidency,
336 dxgi_device_SetGPUThreadPriority,
337 dxgi_device_GetGPUThreadPriority,
338 /* IWineDXGIAdapter methods */
339 dxgi_device_get_wined3d_device,
340 dxgi_device_create_surface,
341 dxgi_device_create_swapchain,
342 };
343
344 HRESULT dxgi_device_init(struct dxgi_device *device, struct dxgi_device_layer *layer,
345 IDXGIFactory *factory, IDXGIAdapter *adapter)
346 {
347 IWineD3DDeviceParent *wined3d_device_parent;
348 IWineDXGIAdapter *wine_adapter;
349 UINT adapter_ordinal;
350 IWineD3D *wined3d;
351 void *layer_base;
352 HRESULT hr;
353
354 device->vtbl = &dxgi_device_vtbl;
355 device->refcount = 1;
356
357 layer_base = device + 1;
358
359 hr = layer->create(layer->id, &layer_base, 0,
360 device, &IID_IUnknown, (void **)&device->child_layer);
361 if (FAILED(hr))
362 {
363 WARN("Failed to create device, returning %#x.\n", hr);
364 goto fail;
365 }
366
367 hr = IDXGIFactory_QueryInterface(factory, &IID_IWineDXGIFactory, (void **)&device->factory);
368 if (FAILED(hr))
369 {
370 WARN("This is not the factory we're looking for, returning %#x.\n", hr);
371 goto fail;
372 }
373 wined3d = IWineDXGIFactory_get_wined3d(device->factory);
374
375 hr = IDXGIAdapter_QueryInterface(adapter, &IID_IWineDXGIAdapter, (void **)&wine_adapter);
376 if (FAILED(hr))
377 {
378 WARN("This is not the adapter we're looking for, returning %#x.\n", hr);
379 EnterCriticalSection(&dxgi_cs);
380 IWineD3D_Release(wined3d);
381 LeaveCriticalSection(&dxgi_cs);
382 goto fail;
383 }
384 adapter_ordinal = IWineDXGIAdapter_get_ordinal(wine_adapter);
385 IWineDXGIAdapter_Release(wine_adapter);
386
387 hr = IUnknown_QueryInterface((IUnknown *)device, &IID_IWineD3DDeviceParent, (void **)&wined3d_device_parent);
388 if (FAILED(hr))
389 {
390 ERR("DXGI device should implement IWineD3DDeviceParent.\n");
391 goto fail;
392 }
393
394 FIXME("Ignoring adapter type.\n");
395 EnterCriticalSection(&dxgi_cs);
396 hr = IWineD3D_CreateDevice(wined3d, adapter_ordinal, WINED3DDEVTYPE_HAL, NULL, 0,
397 (IUnknown *)device, wined3d_device_parent, &device->wined3d_device);
398 IWineD3DDeviceParent_Release(wined3d_device_parent);
399 IWineD3D_Release(wined3d);
400 LeaveCriticalSection(&dxgi_cs);
401 if (FAILED(hr))
402 {
403 WARN("Failed to create a wined3d device, returning %#x.\n", hr);
404 goto fail;
405 }
406
407 return S_OK;
408
409 fail:
410 if (device->wined3d_device)
411 {
412 EnterCriticalSection(&dxgi_cs);
413 IWineD3DDevice_Release(device->wined3d_device);
414 LeaveCriticalSection(&dxgi_cs);
415 }
416 if (device->factory) IWineDXGIFactory_Release(device->factory);
417 if (device->child_layer) IUnknown_Release(device->child_layer);
418 return hr;
419 }
420
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.