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