git.oblomov.eu Git - wine/blob - dlls/d3dcompiler_43/blob.c

   1 /*
   2  * Direct3D blob file
   3  *
   4  * Copyright 2010 Rico Schüller
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include "d3dcompiler_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3dcompiler);
  28
  29 struct d3dcompiler_blob
  30 {
  31     ID3DBlob ID3DBlob_iface;
  32     LONG refcount;
  33
  34     SIZE_T size;
  35     void *data;
  36 };
  37
  38 static inline struct d3dcompiler_blob *impl_from_ID3DBlob(ID3DBlob *iface)
  39 {
  40     return CONTAINING_RECORD(iface, struct d3dcompiler_blob, ID3DBlob_iface);
  41 }
  42
  43 /* IUnknown methods */
  44
  45 static HRESULT STDMETHODCALLTYPE d3dcompiler_blob_QueryInterface(ID3DBlob *iface, REFIID riid, void **object)
  46 {
  47     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
  48
  49     if (IsEqualGUID(riid, &IID_ID3D10Blob)
  50             || IsEqualGUID(riid, &IID_IUnknown))
  51     {
  52         IUnknown_AddRef(iface);
  53         *object = iface;
  54         return S_OK;
  55     }
  56
  57     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  58
  59     *object = NULL;
  60     return E_NOINTERFACE;
  61 }
  62
  63 static ULONG STDMETHODCALLTYPE d3dcompiler_blob_AddRef(ID3DBlob *iface)
  64 {
  65     struct d3dcompiler_blob *blob = impl_from_ID3DBlob(iface);
  66     ULONG refcount = InterlockedIncrement(&blob->refcount);
  67
  68     TRACE("%p increasing refcount to %u\n", blob, refcount);
  69
  70     return refcount;
  71 }
  72
  73 static ULONG STDMETHODCALLTYPE d3dcompiler_blob_Release(ID3DBlob *iface)
  74 {
  75     struct d3dcompiler_blob *blob = impl_from_ID3DBlob(iface);
  76     ULONG refcount = InterlockedDecrement(&blob->refcount);
  77
  78     TRACE("%p decreasing refcount to %u\n", blob, refcount);
  79
  80     if (!refcount)
  81     {
  82         HeapFree(GetProcessHeap(), 0, blob->data);
  83         HeapFree(GetProcessHeap(), 0, blob);
  84     }
  85
  86     return refcount;
  87 }
  88
  89 /* ID3DBlob methods */
  90
  91 static void * STDMETHODCALLTYPE d3dcompiler_blob_GetBufferPointer(ID3DBlob *iface)
  92 {
  93     struct d3dcompiler_blob *blob = impl_from_ID3DBlob(iface);
  94
  95     TRACE("iface %p\n", iface);
  96
  97     return blob->data;
  98 }
  99
 100 static SIZE_T STDMETHODCALLTYPE d3dcompiler_blob_GetBufferSize(ID3DBlob *iface)
 101 {
 102     struct d3dcompiler_blob *blob = impl_from_ID3DBlob(iface);
 103
 104     TRACE("iface %p\n", iface);
 105
 106     return blob->size;
 107 }
 108
 109 static const struct ID3D10BlobVtbl d3dcompiler_blob_vtbl =
 110 {
 111     /* IUnknown methods */
 112     d3dcompiler_blob_QueryInterface,
 113     d3dcompiler_blob_AddRef,
 114     d3dcompiler_blob_Release,
 115     /* ID3DBlob methods */
 116     d3dcompiler_blob_GetBufferPointer,
 117     d3dcompiler_blob_GetBufferSize,
 118 };
 119
 120 static HRESULT d3dcompiler_blob_init(struct d3dcompiler_blob *blob, SIZE_T data_size)
 121 {
 122     blob->ID3DBlob_iface.lpVtbl = &d3dcompiler_blob_vtbl;
 123     blob->refcount = 1;
 124     blob->size = data_size;
 125
 126     blob->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, data_size);
 127     if (!blob->data)
 128     {
 129         ERR("Failed to allocate D3D blob data memory\n");
 130         return E_OUTOFMEMORY;
 131     }
 132
 133     return S_OK;
 134 }
 135
 136 HRESULT WINAPI D3DCreateBlob(SIZE_T data_size, ID3DBlob **blob)
 137 {
 138     struct d3dcompiler_blob *object;
 139     HRESULT hr;
 140
 141     TRACE("data_size %lu, blob %p\n", data_size, blob);
 142
 143     if (!blob)
 144     {
 145         WARN("Invalid blob specified.\n");
 146         return D3DERR_INVALIDCALL;
 147     }
 148
 149     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 150     if (!object)
 151     {
 152         ERR("Failed to allocate D3D blob object memory\n");
 153         return E_OUTOFMEMORY;
 154     }
 155
 156     hr = d3dcompiler_blob_init(object, data_size);
 157     if (FAILED(hr))
 158     {
 159         WARN("Failed to initialize blob, hr %#x.\n", hr);
 160         HeapFree(GetProcessHeap(), 0, object);
 161         return hr;
 162     }
 163
 164     *blob = &object->ID3DBlob_iface;
 165
 166     TRACE("Created ID3DBlob %p\n", *blob);
 167
 168     return S_OK;
 169 }
 170
 171 static BOOL check_blob_part(DWORD tag, D3D_BLOB_PART part)
 172 {
 173     BOOL add = FALSE;
 174
 175     switch(part)
 176     {
 177         case D3D_BLOB_INPUT_SIGNATURE_BLOB:
 178             if (tag == TAG_ISGN) add = TRUE;
 179             break;
 180
 181         case D3D_BLOB_OUTPUT_SIGNATURE_BLOB:
 182             if (tag == TAG_OSGN || tag == TAG_OSG5) add = TRUE;
 183             break;
 184
 185         case D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB:
 186             if (tag == TAG_ISGN || tag == TAG_OSGN || tag == TAG_OSG5) add = TRUE;
 187             break;
 188
 189         case D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB:
 190             if (tag == TAG_PCSG) add = TRUE;
 191             break;
 192
 193         case D3D_BLOB_ALL_SIGNATURE_BLOB:
 194             if (tag == TAG_ISGN || tag == TAG_OSGN || tag == TAG_OSG5 || tag == TAG_PCSG) add = TRUE;
 195             break;
 196
 197         case D3D_BLOB_DEBUG_INFO:
 198             if (tag == TAG_SDBG) add = TRUE;
 199             break;
 200
 201         case D3D_BLOB_LEGACY_SHADER:
 202             if (tag == TAG_Aon9) add = TRUE;
 203             break;
 204
 205         case D3D_BLOB_XNA_PREPASS_SHADER:
 206             if (tag == TAG_XNAP) add = TRUE;
 207             break;
 208
 209         case D3D_BLOB_XNA_SHADER:
 210             if (tag == TAG_XNAS) add = TRUE;
 211             break;
 212
 213         default:
 214             FIXME("Unhandled D3D_BLOB_PART %s.\n", debug_d3dcompiler_d3d_blob_part(part));
 215             break;
 216     }
 217
 218     TRACE("%s tag %s\n", add ? "Add" : "Skip", debugstr_an((const char *)&tag, 4));
 219
 220     return add;
 221 }
 222
 223 static HRESULT d3dcompiler_get_blob_part(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob)
 224 {
 225     struct dxbc src_dxbc, dst_dxbc;
 226     HRESULT hr;
 227     unsigned int i, count;
 228
 229     if (!data || !data_size || flags || !blob)
 230     {
 231         WARN("Invalid arguments: data %p, data_size %lu, flags %#x, blob %p\n", data, data_size, flags, blob);
 232         return D3DERR_INVALIDCALL;
 233     }
 234
 235     if (part > D3D_BLOB_TEST_COMPILE_PERF
 236             || (part < D3D_BLOB_TEST_ALTERNATE_SHADER && part > D3D_BLOB_XNA_SHADER))
 237     {
 238         WARN("Invalid D3D_BLOB_PART: part %s\n", debug_d3dcompiler_d3d_blob_part(part));
 239         return D3DERR_INVALIDCALL;
 240     }
 241
 242     hr = dxbc_parse(data, data_size, &src_dxbc);
 243     if (FAILED(hr))
 244     {
 245         WARN("Failed to parse blob part\n");
 246         return hr;
 247     }
 248
 249     hr = dxbc_init(&dst_dxbc, 0);
 250     if (FAILED(hr))
 251     {
 252         dxbc_destroy(&src_dxbc);
 253         WARN("Failed to init dxbc\n");
 254         return hr;
 255     }
 256
 257     for (i = 0; i < src_dxbc.count; ++i)
 258     {
 259         struct dxbc_section *section = &src_dxbc.sections[i];
 260
 261         if (check_blob_part(section->tag, part))
 262         {
 263             hr = dxbc_add_section(&dst_dxbc, section->tag, section->data, section->data_size);
 264             if (FAILED(hr))
 265             {
 266                 dxbc_destroy(&src_dxbc);
 267                 dxbc_destroy(&dst_dxbc);
 268                 WARN("Failed to add section to dxbc\n");
 269                 return hr;
 270             }
 271         }
 272     }
 273
 274     count = dst_dxbc.count;
 275
 276     switch(part)
 277     {
 278         case D3D_BLOB_INPUT_SIGNATURE_BLOB:
 279         case D3D_BLOB_OUTPUT_SIGNATURE_BLOB:
 280         case D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB:
 281         case D3D_BLOB_DEBUG_INFO:
 282         case D3D_BLOB_LEGACY_SHADER:
 283         case D3D_BLOB_XNA_PREPASS_SHADER:
 284         case D3D_BLOB_XNA_SHADER:
 285             if (count != 1) count = 0;
 286             break;
 287
 288         case D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB:
 289             if (count != 2) count = 0;
 290             break;
 291
 292         case D3D_BLOB_ALL_SIGNATURE_BLOB:
 293             if (count != 3) count = 0;
 294             break;
 295
 296         default:
 297             FIXME("Unhandled D3D_BLOB_PART %s.\n", debug_d3dcompiler_d3d_blob_part(part));
 298             break;
 299     }
 300
 301     if (count == 0)
 302     {
 303         dxbc_destroy(&src_dxbc);
 304         dxbc_destroy(&dst_dxbc);
 305         WARN("Nothing to write into the blob (count = 0)\n");
 306         return E_FAIL;
 307     }
 308
 309     /* some parts aren't full DXBCs, they contain only the data */
 310     if (count == 1 && (part == D3D_BLOB_DEBUG_INFO || part == D3D_BLOB_LEGACY_SHADER || part == D3D_BLOB_XNA_PREPASS_SHADER
 311             || part == D3D_BLOB_XNA_SHADER))
 312     {
 313         hr = D3DCreateBlob(dst_dxbc.sections[0].data_size, blob);
 314         if (SUCCEEDED(hr))
 315         {
 316             memcpy(ID3D10Blob_GetBufferPointer(*blob), dst_dxbc.sections[0].data, dst_dxbc.sections[0].data_size);
 317         }
 318         else
 319         {
 320             WARN("Could not create blob\n");
 321         }
 322     }
 323     else
 324     {
 325         hr = dxbc_write_blob(&dst_dxbc, blob);
 326         if (FAILED(hr))
 327         {
 328             WARN("Failed to write blob part\n");
 329         }
 330     }
 331
 332     dxbc_destroy(&src_dxbc);
 333     dxbc_destroy(&dst_dxbc);
 334
 335     return hr;
 336 }
 337
 338 static BOOL check_blob_strip(DWORD tag, UINT flags)
 339 {
 340     BOOL add = TRUE;
 341
 342     if (flags & D3DCOMPILER_STRIP_TEST_BLOBS) FIXME("Unhandled flag D3DCOMPILER_STRIP_TEST_BLOBS.\n");
 343
 344     switch(tag)
 345     {
 346         case TAG_RDEF:
 347         case TAG_STAT:
 348             if (flags & D3DCOMPILER_STRIP_REFLECTION_DATA) add = FALSE;
 349             break;
 350
 351         case TAG_SDBG:
 352             if (flags & D3DCOMPILER_STRIP_DEBUG_INFO) add = FALSE;
 353             break;
 354
 355         default:
 356             break;
 357     }
 358
 359     TRACE("%s tag %s\n", add ? "Add" : "Skip", debugstr_an((const char *)&tag, 4));
 360
 361     return add;
 362 }
 363
 364 static HRESULT d3dcompiler_strip_shader(const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob)
 365 {
 366     struct dxbc src_dxbc, dst_dxbc;
 367     HRESULT hr;
 368     unsigned int i;
 369
 370     if (!blob)
 371     {
 372         WARN("NULL for blob specified\n");
 373         return E_FAIL;
 374     }
 375
 376     if (!data || !data_size)
 377     {
 378         WARN("Invalid arguments: data %p, data_size %lu\n", data, data_size);
 379         return D3DERR_INVALIDCALL;
 380     }
 381
 382     hr = dxbc_parse(data, data_size, &src_dxbc);
 383     if (FAILED(hr))
 384     {
 385         WARN("Failed to parse blob part\n");
 386         return hr;
 387     }
 388
 389     /* src_dxbc.count >= dst_dxbc.count */
 390     hr = dxbc_init(&dst_dxbc, src_dxbc.count);
 391     if (FAILED(hr))
 392     {
 393         dxbc_destroy(&src_dxbc);
 394         WARN("Failed to init dxbc\n");
 395         return hr;
 396     }
 397
 398     for (i = 0; i < src_dxbc.count; ++i)
 399     {
 400         struct dxbc_section *section = &src_dxbc.sections[i];
 401
 402         if (check_blob_strip(section->tag, flags))
 403         {
 404             hr = dxbc_add_section(&dst_dxbc, section->tag, section->data, section->data_size);
 405             if (FAILED(hr))
 406             {
 407                 dxbc_destroy(&src_dxbc);
 408                 dxbc_destroy(&dst_dxbc);
 409                 WARN("Failed to add section to dxbc\n");
 410                 return hr;
 411             }
 412         }
 413     }
 414
 415     hr = dxbc_write_blob(&dst_dxbc, blob);
 416     if (FAILED(hr))
 417     {
 418         WARN("Failed to write blob part\n");
 419     }
 420
 421     dxbc_destroy(&src_dxbc);
 422     dxbc_destroy(&dst_dxbc);
 423
 424     return hr;
 425 }
 426
 427 HRESULT WINAPI D3DGetBlobPart(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob)
 428 {
 429     TRACE("data %p, data_size %lu, part %s, flags %#x, blob %p\n", data,
 430            data_size, debug_d3dcompiler_d3d_blob_part(part), flags, blob);
 431
 432     return d3dcompiler_get_blob_part(data, data_size, part, flags, blob);
 433 }
 434
 435 HRESULT WINAPI D3DGetInputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
 436 {
 437     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 438
 439     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_SIGNATURE_BLOB, 0, blob);
 440 }
 441
 442 HRESULT WINAPI D3DGetOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
 443 {
 444     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 445
 446     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_OUTPUT_SIGNATURE_BLOB, 0, blob);
 447 }
 448
 449 HRESULT WINAPI D3DGetInputAndOutputSignatureBlob(const void *data, SIZE_T data_size, ID3DBlob **blob)
 450 {
 451     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 452
 453     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB, 0, blob);
 454 }
 455
 456 HRESULT WINAPI D3DGetDebugInfo(const void *data, SIZE_T data_size, ID3DBlob **blob)
 457 {
 458     TRACE("data %p, data_size %lu, blob %p\n", data, data_size, blob);
 459
 460     return d3dcompiler_get_blob_part(data, data_size, D3D_BLOB_DEBUG_INFO, 0, blob);
 461 }
 462
 463 HRESULT WINAPI D3DStripShader(const void *data, SIZE_T data_size, UINT flags, ID3D10Blob **blob)
 464 {
 465     TRACE("data %p, data_size %lu, flags %#x, blob %p\n", data, data_size, flags, blob);
 466
 467     return d3dcompiler_strip_shader(data, data_size, flags, blob);
 468 }