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