dlls/d3dx11_43/async.c

   1 /*
   2  * Copyright 2016 Matteo Bruni 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 #include "d3dx11.h"
  20 #include "d3dcompiler.h"
  21
  22 #include "wine/debug.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
  25
  26 struct asyncdataloader
  27 {
  28     ID3DX11DataLoader ID3DX11DataLoader_iface;
  29
  30     union
  31     {
  32         struct
  33         {
  34             WCHAR *path;
  35         } file;
  36         struct
  37         {
  38             HMODULE module;
  39             HRSRC rsrc;
  40         } resource;
  41     } u;
  42     void *data;
  43     SIZE_T size;
  44 };
  45
  46 static inline struct asyncdataloader *impl_from_ID3DX11DataLoader(ID3DX11DataLoader *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct asyncdataloader, ID3DX11DataLoader_iface);
  49 }
  50
  51 static HRESULT WINAPI memorydataloader_Load(ID3DX11DataLoader *iface)
  52 {
  53     TRACE("iface %p.\n", iface);
  54     return S_OK;
  55 }
  56
  57 static HRESULT WINAPI memorydataloader_Decompress(ID3DX11DataLoader *iface, void **data, SIZE_T *size)
  58 {
  59     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
  60
  61     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
  62
  63     *data = loader->data;
  64     *size = loader->size;
  65
  66     return S_OK;
  67 }
  68
  69 static HRESULT WINAPI memorydataloader_Destroy(ID3DX11DataLoader *iface)
  70 {
  71     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
  72
  73     TRACE("iface %p.\n", iface);
  74
  75     HeapFree(GetProcessHeap(), 0, loader);
  76     return S_OK;
  77 }
  78
  79 static const ID3DX11DataLoaderVtbl memorydataloadervtbl =
  80 {
  81     memorydataloader_Load,
  82     memorydataloader_Decompress,
  83     memorydataloader_Destroy
  84 };
  85
  86 static HRESULT WINAPI filedataloader_Load(ID3DX11DataLoader *iface)
  87 {
  88     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
  89     DWORD size, read_len;
  90     HANDLE file;
  91     void *data;
  92     BOOL ret;
  93
  94     TRACE("iface %p.\n", iface);
  95
  96     /* Always buffer file contents, even if Load() was already called. */
  97     file = CreateFileW(loader->u.file.path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
  98             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  99     if (file == INVALID_HANDLE_VALUE)
 100         return D3D11_ERROR_FILE_NOT_FOUND;
 101
 102     size = GetFileSize(file, NULL);
 103     data = HeapAlloc(GetProcessHeap(), 0, size);
 104     if (!data)
 105     {
 106         CloseHandle(file);
 107         return E_OUTOFMEMORY;
 108     }
 109
 110     ret = ReadFile(file, data, size, &read_len, NULL);
 111     CloseHandle(file);
 112     if (!ret)
 113     {
 114         ERR("Failed to read file contents.\n");
 115         HeapFree(GetProcessHeap(), 0, data);
 116         return E_FAIL;
 117     }
 118
 119     HeapFree(GetProcessHeap(), 0, loader->data);
 120     loader->data = data;
 121     loader->size = size;
 122
 123     return S_OK;
 124 }
 125
 126 static HRESULT WINAPI filedataloader_Decompress(ID3DX11DataLoader *iface, void **data, SIZE_T *size)
 127 {
 128     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
 129
 130     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 131
 132     if (!loader->data)
 133         return E_FAIL;
 134
 135     *data = loader->data;
 136     *size = loader->size;
 137
 138     return S_OK;
 139 }
 140
 141 static HRESULT WINAPI filedataloader_Destroy(ID3DX11DataLoader *iface)
 142 {
 143     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
 144
 145     TRACE("iface %p.\n", iface);
 146
 147     HeapFree(GetProcessHeap(), 0, loader->u.file.path);
 148     HeapFree(GetProcessHeap(), 0, loader->data);
 149     HeapFree(GetProcessHeap(), 0, loader);
 150
 151     return S_OK;
 152 }
 153
 154 static const ID3DX11DataLoaderVtbl filedataloadervtbl =
 155 {
 156     filedataloader_Load,
 157     filedataloader_Decompress,
 158     filedataloader_Destroy
 159 };
 160
 161 static HRESULT WINAPI resourcedataloader_Load(ID3DX11DataLoader *iface)
 162 {
 163     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
 164     HGLOBAL hglobal;
 165
 166     TRACE("iface %p.\n", iface);
 167
 168     if (loader->data)
 169         return S_OK;
 170
 171     hglobal = LoadResource(loader->u.resource.module, loader->u.resource.rsrc);
 172     if (!hglobal)
 173     {
 174         ERR("Failed to load resource.\n");
 175         return E_FAIL;
 176     }
 177
 178     loader->data = LockResource(hglobal);
 179     loader->size = SizeofResource(loader->u.resource.module, loader->u.resource.rsrc);
 180
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI resourcedataloader_Decompress(ID3DX11DataLoader *iface, void **data, SIZE_T *size)
 185 {
 186     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
 187
 188     TRACE("iface %p, data %p, size %p.\n", iface, data, size);
 189
 190     if (!loader->data)
 191         return E_FAIL;
 192
 193     *data = loader->data;
 194     *size = loader->size;
 195
 196     return S_OK;
 197 }
 198
 199 static HRESULT WINAPI resourcedataloader_Destroy(ID3DX11DataLoader *iface)
 200 {
 201     struct asyncdataloader *loader = impl_from_ID3DX11DataLoader(iface);
 202
 203     TRACE("iface %p.\n", iface);
 204
 205     HeapFree(GetProcessHeap(), 0, loader);
 206
 207     return S_OK;
 208 }
 209
 210 static const ID3DX11DataLoaderVtbl resourcedataloadervtbl =
 211 {
 212     resourcedataloader_Load,
 213     resourcedataloader_Decompress,
 214     resourcedataloader_Destroy
 215 };
 216
 217 HRESULT WINAPI D3DX11CompileFromMemory(const char *data, SIZE_T data_size, const char *filename,
 218         const D3D10_SHADER_MACRO *defines, ID3D10Include *include, const char *entry_point,
 219         const char *target, UINT sflags, UINT eflags, ID3DX11ThreadPump *pump, ID3D10Blob **shader,
 220         ID3D10Blob **error_messages, HRESULT *hresult)
 221 {
 222     TRACE("data %s, data_size %lu, filename %s, defines %p, include %p, entry_point %s, target %s, "
 223             "sflags %#x, eflags %#x, pump %p, shader %p, error_messages %p, hresult %p.\n",
 224             debugstr_an(data, data_size), data_size, debugstr_a(filename), defines, include,
 225             debugstr_a(entry_point), debugstr_a(target), sflags, eflags, pump, shader,
 226             error_messages, hresult);
 227
 228     if (pump)
 229         FIXME("Unimplemented ID3DX11ThreadPump handling.\n");
 230
 231     return D3DCompile(data, data_size, filename, defines, include, entry_point, target,
 232             sflags, eflags, shader, error_messages);
 233 }
 234
 235 HRESULT WINAPI D3DX11CompileFromFileA(const char *filename, const D3D10_SHADER_MACRO *defines,
 236         ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags,
 237         ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)
 238 {
 239     FIXME("filename %s, defines %p, include %p, entry_point %s, target %s, sflags %#x, "
 240             "eflags %#x, pump %p, shader %p, error_messages %p, hresult %p stub.\n",
 241             debugstr_a(filename), defines, include, debugstr_a(entry_point), debugstr_a(target),
 242             sflags, eflags, pump, shader, error_messages, hresult);
 243
 244     return E_NOTIMPL;
 245 }
 246
 247 HRESULT WINAPI D3DX11CompileFromFileW(const WCHAR *filename, const D3D10_SHADER_MACRO *defines,
 248         ID3D10Include *include, const char *entry_point, const char *target, UINT sflags, UINT eflags,
 249         ID3DX11ThreadPump *pump, ID3D10Blob **shader, ID3D10Blob **error_messages, HRESULT *hresult)
 250 {
 251     FIXME("filename %s, defines %p, include %p, entry_point %s, target %s, sflags %#x, "
 252             "eflags %#x, pump %p, shader %p, error_messages %p, hresult %p stub.\n",
 253             debugstr_w(filename), defines, include, debugstr_a(entry_point), debugstr_a(target),
 254             sflags, eflags, pump, shader, error_messages, hresult);
 255
 256     return E_NOTIMPL;
 257 }
 258
 259 HRESULT WINAPI D3DX11CreateAsyncMemoryLoader(const void *data, SIZE_T data_size, ID3DX11DataLoader **loader)
 260 {
 261     struct asyncdataloader *object;
 262
 263     TRACE("data %p, data_size %lu, loader %p.\n", data, data_size, loader);
 264
 265     if (!data || !loader)
 266         return E_FAIL;
 267
 268     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 269     if (!object)
 270         return E_OUTOFMEMORY;
 271
 272     object->ID3DX11DataLoader_iface.lpVtbl = &memorydataloadervtbl;
 273     object->data = (void *)data;
 274     object->size = data_size;
 275
 276     *loader = &object->ID3DX11DataLoader_iface;
 277
 278     return S_OK;
 279 }
 280
 281 HRESULT WINAPI D3DX11CreateAsyncFileLoaderA(const char *filename, ID3DX11DataLoader **loader)
 282 {
 283     WCHAR *filename_w;
 284     HRESULT hr;
 285     int len;
 286
 287     TRACE("filename %s, loader %p.\n", debugstr_a(filename), loader);
 288
 289     if (!filename || !loader)
 290         return E_FAIL;
 291
 292     len = MultiByteToWideChar(CP_ACP, 0, filename, -1, NULL, 0);
 293     filename_w = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*filename_w));
 294     MultiByteToWideChar(CP_ACP, 0, filename, -1, filename_w, len);
 295
 296     hr = D3DX11CreateAsyncFileLoaderW(filename_w, loader);
 297
 298     HeapFree(GetProcessHeap(), 0, filename_w);
 299
 300     return hr;
 301 }
 302
 303 HRESULT WINAPI D3DX11CreateAsyncFileLoaderW(const WCHAR *filename, ID3DX11DataLoader **loader)
 304 {
 305     struct asyncdataloader *object;
 306
 307     TRACE("filename %s, loader %p.\n", debugstr_w(filename), loader);
 308
 309     if (!filename || !loader)
 310         return E_FAIL;
 311
 312     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 313     if (!object)
 314         return E_OUTOFMEMORY;
 315
 316     object->ID3DX11DataLoader_iface.lpVtbl = &filedataloadervtbl;
 317     object->u.file.path = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
 318     if (!object->u.file.path)
 319     {
 320         HeapFree(GetProcessHeap(), 0, object);
 321         return E_OUTOFMEMORY;
 322     }
 323     lstrcpyW(object->u.file.path, filename);
 324     object->data = NULL;
 325     object->size = 0;
 326
 327     *loader = &object->ID3DX11DataLoader_iface;
 328
 329     return S_OK;
 330 }
 331
 332 HRESULT WINAPI D3DX11CreateAsyncResourceLoaderA(HMODULE module, const char *resource, ID3DX11DataLoader **loader)
 333 {
 334     struct asyncdataloader *object;
 335     HRSRC rsrc;
 336
 337     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_a(resource), loader);
 338
 339     if (!loader)
 340         return E_FAIL;
 341
 342     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 343     if (!object)
 344         return E_OUTOFMEMORY;
 345
 346     if (!(rsrc = FindResourceA(module, resource, (const char *)RT_RCDATA)))
 347     {
 348         WARN("Failed to find resource.\n");
 349         HeapFree(GetProcessHeap(), 0, object);
 350         return D3DX11_ERR_INVALID_DATA;
 351     }
 352
 353     object->ID3DX11DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 354     object->u.resource.module = module;
 355     object->u.resource.rsrc = rsrc;
 356     object->data = NULL;
 357     object->size = 0;
 358
 359     *loader = &object->ID3DX11DataLoader_iface;
 360
 361     return S_OK;
 362 }
 363
 364 HRESULT WINAPI D3DX11CreateAsyncResourceLoaderW(HMODULE module, const WCHAR *resource, ID3DX11DataLoader **loader)
 365 {
 366     struct asyncdataloader *object;
 367     HRSRC rsrc;
 368
 369     TRACE("module %p, resource %s, loader %p.\n", module, debugstr_w(resource), loader);
 370
 371     if (!loader)
 372         return E_FAIL;
 373
 374     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 375     if (!object)
 376         return E_OUTOFMEMORY;
 377
 378     if (!(rsrc = FindResourceW(module, resource, (const WCHAR *)RT_RCDATA)))
 379     {
 380         WARN("Failed to find resource.\n");
 381         HeapFree(GetProcessHeap(), 0, object);
 382         return D3DX11_ERR_INVALID_DATA;
 383     }
 384
 385     object->ID3DX11DataLoader_iface.lpVtbl = &resourcedataloadervtbl;
 386     object->u.resource.module = module;
 387     object->u.resource.rsrc = rsrc;
 388     object->data = NULL;
 389     object->size = 0;
 390
 391     *loader = &object->ID3DX11DataLoader_iface;
 392
 393     return S_OK;
 394 }