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     HeapFree(GetProcessHeap(), 0, 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 CreateDXGIFactory1(REFIID riid, void **factory)
  60 {
  61     TRACE("riid %s, factory %p\n", debugstr_guid(riid), factory);
  62
  63     return dxgi_factory_create(riid, factory, TRUE);
  64 }
  65
  66 HRESULT WINAPI CreateDXGIFactory(REFIID riid, void **factory)
  67 {
  68     TRACE("riid %s, factory %p\n", debugstr_guid(riid), factory);
  69
  70     return dxgi_factory_create(riid, factory, FALSE);
  71 }
  72
  73 static BOOL get_layer(enum dxgi_device_layer_id id, struct dxgi_device_layer *layer)
  74 {
  75     UINT i;
  76
  77     wined3d_mutex_lock();
  78
  79     for (i = 0; i < dxgi_main.layer_count; ++i)
  80     {
  81         if (dxgi_main.device_layers[i].id == id)
  82         {
  83             *layer = dxgi_main.device_layers[i];
  84             wined3d_mutex_unlock();
  85             return TRUE;
  86         }
  87     }
  88
  89     wined3d_mutex_unlock();
  90     return FALSE;
  91 }
  92
  93 static HRESULT register_d3d10core_layers(HMODULE d3d10core)
  94 {
  95     wined3d_mutex_lock();
  96
  97     if (!dxgi_main.d3d10core)
  98     {
  99         HRESULT hr;
 100         HRESULT (WINAPI *d3d11core_register_layers)(void);
 101         HMODULE mod;
 102         BOOL ret;
 103
 104         if (!(ret = GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (const char *)d3d10core, &mod)))
 105         {
 106             wined3d_mutex_unlock();
 107             return E_FAIL;
 108         }
 109
 110         d3d11core_register_layers = (void *)GetProcAddress(mod, "D3D11CoreRegisterLayers");
 111         hr = d3d11core_register_layers();
 112         if (FAILED(hr))
 113         {
 114             ERR("Failed to register d3d11 layers, returning %#x\n", hr);
 115             wined3d_mutex_unlock();
 116             return hr;
 117         }
 118
 119         dxgi_main.d3d10core = mod;
 120     }
 121
 122     wined3d_mutex_unlock();
 123
 124     return S_OK;
 125 }
 126
 127 HRESULT WINAPI DXGID3D10CreateDevice(HMODULE d3d10core, IDXGIFactory *factory, IDXGIAdapter *adapter,
 128         UINT flags, void *unknown0, void **device)
 129 {
 130     struct layer_get_size_args get_size_args;
 131     struct dxgi_device *dxgi_device;
 132     struct dxgi_device_layer d3d10_layer;
 133     UINT device_size;
 134     DWORD count;
 135     HRESULT hr;
 136
 137     TRACE("d3d10core %p, factory %p, adapter %p, flags %#x, unknown0 %p, device %p.\n",
 138             d3d10core, factory, adapter, flags, unknown0, device);
 139
 140     hr = register_d3d10core_layers(d3d10core);
 141     if (FAILED(hr))
 142     {
 143         ERR("Failed to register d3d10core layers, returning %#x\n", hr);
 144         return hr;
 145     }
 146
 147     if (!get_layer(DXGI_DEVICE_LAYER_D3D10_DEVICE, &d3d10_layer))
 148     {
 149         ERR("Failed to get D3D10 device layer\n");
 150         return E_FAIL;
 151     }
 152
 153     count = 0;
 154     hr = d3d10_layer.init(d3d10_layer.id, &count, NULL);
 155     if (FAILED(hr))
 156     {
 157         WARN("Failed to initialize D3D10 device layer\n");
 158         return E_FAIL;
 159     }
 160
 161     get_size_args.unknown0 = 0;
 162     get_size_args.unknown1 = 0;
 163     get_size_args.unknown2 = NULL;
 164     get_size_args.unknown3 = NULL;
 165     get_size_args.adapter = adapter;
 166     get_size_args.interface_major = 10;
 167     get_size_args.interface_minor = 1;
 168     get_size_args.version_build = 4;
 169     get_size_args.version_revision = 6000;
 170
 171     device_size = d3d10_layer.get_size(d3d10_layer.id, &get_size_args, 0);
 172     device_size += sizeof(*dxgi_device);
 173
 174     dxgi_device = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, device_size);
 175     if (!dxgi_device)
 176     {
 177         ERR("Failed to allocate device memory\n");
 178         return E_OUTOFMEMORY;
 179     }
 180
 181     hr = dxgi_device_init(dxgi_device, &d3d10_layer, factory, adapter);
 182     if (FAILED(hr))
 183     {
 184         WARN("Failed to initialize device, hr %#x.\n", hr);
 185         HeapFree(GetProcessHeap(), 0, dxgi_device);
 186         *device = NULL;
 187         return hr;
 188     }
 189
 190     TRACE("Created device %p.\n", dxgi_device);
 191     *device = dxgi_device;
 192
 193     return S_OK;
 194 }
 195
 196 HRESULT WINAPI DXGID3D10RegisterLayers(const struct dxgi_device_layer *layers, UINT layer_count)
 197 {
 198     UINT i;
 199     struct dxgi_device_layer *new_layers;
 200
 201     TRACE("layers %p, layer_count %u\n", layers, layer_count);
 202
 203     wined3d_mutex_lock();
 204
 205     if (!dxgi_main.layer_count)
 206         new_layers = HeapAlloc(GetProcessHeap(), 0, layer_count * sizeof(*new_layers));
 207     else
 208         new_layers = HeapReAlloc(GetProcessHeap(), 0, dxgi_main.device_layers,
 209                 (dxgi_main.layer_count + layer_count) * sizeof(*new_layers));
 210
 211     if (!new_layers)
 212     {
 213         wined3d_mutex_unlock();
 214         ERR("Failed to allocate layer memory\n");
 215         return E_OUTOFMEMORY;
 216     }
 217
 218     for (i = 0; i < layer_count; ++i)
 219     {
 220         const struct dxgi_device_layer *layer = &layers[i];
 221
 222         TRACE("layer %d: id %#x, init %p, get_size %p, create %p\n",
 223                 i, layer->id, layer->init, layer->get_size, layer->create);
 224
 225         new_layers[dxgi_main.layer_count + i] = *layer;
 226     }
 227
 228     dxgi_main.device_layers = new_layers;
 229     dxgi_main.layer_count += layer_count;
 230
 231     wined3d_mutex_unlock();
 232
 233     return S_OK;
 234 }