dlls/dxgi/dxgi_main.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 #define DXGI_INIT_GUID
  24 #include "dxgi_private.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(dxgi);
  27
  28 struct dxgi_main
  29 {
  30     HMODULE d3d10core;
  31     struct dxgi_device_layer *device_layers;
  32     UINT layer_count;
  33 };
  34 static struct dxgi_main dxgi_main;
  35
  36 static void dxgi_main_cleanup(void)
  37 {
  38     heap_free(dxgi_main.device_layers);
  39     FreeLibrary(dxgi_main.d3d10core);
  40 }
  41
  42 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
  43 {
  44     switch (reason)
  45     {
  46         case DLL_PROCESS_ATTACH:
  47             DisableThreadLibraryCalls(inst);
  48             break;
  49
  50         case DLL_PROCESS_DETACH:
  51             if (!reserved)
  52                 dxgi_main_cleanup();
  53             break;
  54     }
  55
  56     return TRUE;
  57 }
  58
  59 HRESULT WINAPI CreateDXGIFactory2(UINT flags, REFIID iid, void **factory)
  60 {
  61     TRACE("flags %#x, iid %s, factory %p.\n", flags, debugstr_guid(iid), factory);
  62
  63     if (flags)
  64         FIXME("Ignoring flags %#x.\n", flags);
  65
  66     return dxgi_factory_create(iid, factory, TRUE);
  67 }
  68
  69 HRESULT WINAPI CreateDXGIFactory1(REFIID iid, void **factory)
  70 {
  71     TRACE("iid %s, factory %p.\n", debugstr_guid(iid), factory);
  72
  73     return dxgi_factory_create(iid, factory, TRUE);
  74 }
  75
  76 HRESULT WINAPI CreateDXGIFactory(REFIID iid, void **factory)
  77 {
  78     TRACE("iid %s, factory %p.\n", debugstr_guid(iid), factory);
  79
  80     return dxgi_factory_create(iid, factory, FALSE);
  81 }
  82
  83 static BOOL get_layer(enum dxgi_device_layer_id id, struct dxgi_device_layer *layer)
  84 {
  85     UINT i;
  86
  87     wined3d_mutex_lock();
  88
  89     for (i = 0; i < dxgi_main.layer_count; ++i)
  90     {
  91         if (dxgi_main.device_layers[i].id == id)
  92         {
  93             *layer = dxgi_main.device_layers[i];
  94             wined3d_mutex_unlock();
  95             return TRUE;
  96         }
  97     }
  98
  99     wined3d_mutex_unlock();
 100     return FALSE;
 101 }
 102
 103 static HRESULT register_d3d10core_layers(HMODULE d3d10core)
 104 {
 105     wined3d_mutex_lock();
 106
 107     if (!dxgi_main.d3d10core)
 108     {
 109         HRESULT hr;
 110         HRESULT (WINAPI *d3d11core_register_layers)(void);
 111         HMODULE mod;
 112         BOOL ret;
 113
 114         if (!(ret = GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char *)d3d10core, &mod)))
 115         {
 116             wined3d_mutex_unlock();
 117             return E_FAIL;
 118         }
 119
 120         d3d11core_register_layers = (void *)GetProcAddress(mod, "D3D11CoreRegisterLayers");
 121         hr = d3d11core_register_layers();
 122         if (FAILED(hr))
 123         {
 124             ERR("Failed to register d3d11 layers, returning %#x.\n", hr);
 125             FreeLibrary(mod);
 126             wined3d_mutex_unlock();
 127             return hr;
 128         }
 129
 130         dxgi_main.d3d10core = mod;
 131     }
 132
 133     wined3d_mutex_unlock();
 134
 135     return S_OK;
 136 }
 137
 138 HRESULT WINAPI DXGID3D10CreateDevice(HMODULE d3d10core, IDXGIFactory *factory, IDXGIAdapter *adapter,
 139         unsigned int flags, const D3D_FEATURE_LEVEL *feature_levels, unsigned int level_count, void **device)
 140 {
 141     struct layer_get_size_args get_size_args;
 142     struct dxgi_device_layer d3d10_layer;
 143     struct dxgi_device *dxgi_device;
 144     UINT device_size;
 145     DWORD count;
 146     HRESULT hr;
 147
 148     TRACE("d3d10core %p, factory %p, adapter %p, flags %#x, feature_levels %p, level_count %u, device %p.\n",
 149             d3d10core, factory, adapter, flags, feature_levels, level_count, device);
 150
 151     if (flags)
 152         FIXME("Ignoring flags %#x.\n", flags);
 153
 154     if (TRACE_ON(dxgi))
 155         dump_feature_levels(feature_levels, level_count);
 156
 157     hr = register_d3d10core_layers(d3d10core);
 158     if (FAILED(hr))
 159     {
 160         ERR("Failed to register d3d10core layers, returning %#x.\n", hr);
 161         return hr;
 162     }
 163
 164     if (!get_layer(DXGI_DEVICE_LAYER_D3D10_DEVICE, &d3d10_layer))
 165     {
 166         ERR("Failed to get D3D10 device layer.\n");
 167         return E_FAIL;
 168     }
 169
 170     count = 0;
 171     hr = d3d10_layer.init(d3d10_layer.id, &count, NULL);
 172     if (FAILED(hr))
 173     {
 174         WARN("Failed to initialize D3D10 device layer.\n");
 175         return E_FAIL;
 176     }
 177
 178     get_size_args.unknown0 = 0;
 179     get_size_args.unknown1 = 0;
 180     get_size_args.unknown2 = NULL;
 181     get_size_args.unknown3 = NULL;
 182     get_size_args.adapter = adapter;
 183     get_size_args.interface_major = 10;
 184     get_size_args.interface_minor = 1;
 185     get_size_args.version_build = 4;
 186     get_size_args.version_revision = 6000;
 187
 188     device_size = d3d10_layer.get_size(d3d10_layer.id, &get_size_args, 0);
 189     device_size += sizeof(*dxgi_device);
 190
 191     if (!(dxgi_device = heap_alloc_zero(device_size)))
 192     {
 193         ERR("Failed to allocate device memory.\n");
 194         return E_OUTOFMEMORY;
 195     }
 196
 197     hr = dxgi_device_init(dxgi_device, &d3d10_layer, factory, adapter, feature_levels, level_count);
 198     if (FAILED(hr))
 199     {
 200         WARN("Failed to initialize device, hr %#x.\n", hr);
 201         heap_free(dxgi_device);
 202         *device = NULL;
 203         return hr;
 204     }
 205
 206     TRACE("Created device %p.\n", dxgi_device);
 207     *device = &dxgi_device->IWineDXGIDevice_iface;
 208
 209     return S_OK;
 210 }
 211
 212 HRESULT WINAPI DXGID3D10RegisterLayers(const struct dxgi_device_layer *layers, UINT layer_count)
 213 {
 214     UINT i;
 215     struct dxgi_device_layer *new_layers;
 216
 217     TRACE("layers %p, layer_count %u\n", layers, layer_count);
 218
 219     wined3d_mutex_lock();
 220
 221     if (!dxgi_main.layer_count)
 222         new_layers = heap_alloc(layer_count * sizeof(*new_layers));
 223     else
 224         new_layers = heap_realloc(dxgi_main.device_layers,
 225                 (dxgi_main.layer_count + layer_count) * sizeof(*new_layers));
 226
 227     if (!new_layers)
 228     {
 229         wined3d_mutex_unlock();
 230         ERR("Failed to allocate layer memory\n");
 231         return E_OUTOFMEMORY;
 232     }
 233
 234     for (i = 0; i < layer_count; ++i)
 235     {
 236         const struct dxgi_device_layer *layer = &layers[i];
 237
 238         TRACE("layer %d: id %#x, init %p, get_size %p, create %p\n",
 239                 i, layer->id, layer->init, layer->get_size, layer->create);
 240
 241         new_layers[dxgi_main.layer_count + i] = *layer;
 242     }
 243
 244     dxgi_main.device_layers = new_layers;
 245     dxgi_main.layer_count += layer_count;
 246
 247     wined3d_mutex_unlock();
 248
 249     return S_OK;
 250 }