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 /* IUnknown methods */
  30
  31 static HRESULT STDMETHODCALLTYPE d3dcompiler_blob_QueryInterface(ID3DBlob *iface, REFIID riid, void **object)
  32 {
  33     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
  34
  35     if (IsEqualGUID(riid, &IID_ID3D10Blob)
  36             || IsEqualGUID(riid, &IID_IUnknown))
  37     {
  38         IUnknown_AddRef(iface);
  39         *object = iface;
  40         return S_OK;
  41     }
  42
  43     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
  44
  45     *object = NULL;
  46     return E_NOINTERFACE;
  47 }
  48
  49 static ULONG STDMETHODCALLTYPE d3dcompiler_blob_AddRef(ID3DBlob *iface)
  50 {
  51     struct d3dcompiler_blob *blob = (struct d3dcompiler_blob *)iface;
  52     ULONG refcount = InterlockedIncrement(&blob->refcount);
  53
  54     TRACE("%p increasing refcount to %u\n", blob, refcount);
  55
  56     return refcount;
  57 }
  58
  59 static ULONG STDMETHODCALLTYPE d3dcompiler_blob_Release(ID3DBlob *iface)
  60 {
  61     struct d3dcompiler_blob *blob = (struct d3dcompiler_blob *)iface;
  62     ULONG refcount = InterlockedDecrement(&blob->refcount);
  63
  64     TRACE("%p decreasing refcount to %u\n", blob, refcount);
  65
  66     if (!refcount)
  67     {
  68         HeapFree(GetProcessHeap(), 0, blob->data);
  69         HeapFree(GetProcessHeap(), 0, blob);
  70     }
  71
  72     return refcount;
  73 }
  74
  75 /* ID3DBlob methods */
  76
  77 static void * STDMETHODCALLTYPE d3dcompiler_blob_GetBufferPointer(ID3DBlob *iface)
  78 {
  79     struct d3dcompiler_blob *blob = (struct d3dcompiler_blob *)iface;
  80
  81     TRACE("iface %p\n", iface);
  82
  83     return blob->data;
  84 }
  85
  86 static SIZE_T STDMETHODCALLTYPE d3dcompiler_blob_GetBufferSize(ID3DBlob *iface)
  87 {
  88     struct d3dcompiler_blob *blob = (struct d3dcompiler_blob *)iface;
  89
  90     TRACE("iface %p\n", iface);
  91
  92     return blob->size;
  93 }
  94
  95 static const struct ID3D10BlobVtbl d3dcompiler_blob_vtbl =
  96 {
  97     /* IUnknown methods */
  98     d3dcompiler_blob_QueryInterface,
  99     d3dcompiler_blob_AddRef,
 100     d3dcompiler_blob_Release,
 101     /* ID3DBlob methods */
 102     d3dcompiler_blob_GetBufferPointer,
 103     d3dcompiler_blob_GetBufferSize,
 104 };
 105
 106 HRESULT d3dcompiler_blob_init(struct d3dcompiler_blob *blob, SIZE_T data_size)
 107 {
 108     blob->vtbl = &d3dcompiler_blob_vtbl;
 109     blob->refcount = 1;
 110     blob->size = data_size;
 111
 112     blob->data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, data_size);
 113     if (!blob->data)
 114     {
 115         ERR("Failed to allocate D3D blob data memory\n");
 116         return E_OUTOFMEMORY;
 117     }
 118
 119     return S_OK;
 120 }
 121
 122 static BOOL check_blob_part(DWORD tag, D3D_BLOB_PART part)
 123 {
 124     BOOL add = FALSE;
 125
 126     switch(part)
 127     {
 128         case D3D_BLOB_INPUT_SIGNATURE_BLOB:
 129             if (tag == TAG_ISGN) add = TRUE;
 130             break;
 131
 132         case D3D_BLOB_OUTPUT_SIGNATURE_BLOB:
 133             if (tag == TAG_OSGN) add = TRUE;
 134             break;
 135
 136         case D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB:
 137             if (tag == TAG_ISGN || tag == TAG_OSGN) add = TRUE;
 138             break;
 139
 140         case D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB:
 141             if (tag == TAG_PCSG) add = TRUE;
 142             break;
 143
 144         case D3D_BLOB_ALL_SIGNATURE_BLOB:
 145             if (tag == TAG_ISGN || tag == TAG_OSGN || tag == TAG_PCSG) add = TRUE;
 146             break;
 147
 148         case D3D_BLOB_DEBUG_INFO:
 149             if (tag == TAG_SDBG) add = TRUE;
 150             break;
 151
 152         case D3D_BLOB_LEGACY_SHADER:
 153             if (tag == TAG_Aon9) add = TRUE;
 154             break;
 155
 156         case D3D_BLOB_XNA_PREPASS_SHADER:
 157             if (tag == TAG_XNAP) add = TRUE;
 158             break;
 159
 160         case D3D_BLOB_XNA_SHADER:
 161             if (tag == TAG_XNAS) add = TRUE;
 162             break;
 163
 164         default:
 165             FIXME("Unhandled D3D_BLOB_PART %s.\n", debug_d3dcompiler_d3d_blob_part(part));
 166             break;
 167     }
 168
 169     TRACE("%s tag %s\n", add ? "Add" : "Skip", debugstr_an((const char *)&tag, 4));
 170
 171     return add;
 172 }
 173
 174 HRESULT d3dcompiler_get_blob_part(const void *data, SIZE_T data_size, D3D_BLOB_PART part, UINT flags, ID3DBlob **blob)
 175 {
 176     struct dxbc src_dxbc, dst_dxbc;
 177     HRESULT hr;
 178     unsigned int i, count;
 179
 180     if (!data || !data_size || flags || !blob)
 181     {
 182         WARN("Invalid arguments: data %p, data_size %lu, flags %#x, blob %p\n", data, data_size, flags, blob);
 183         return D3DERR_INVALIDCALL;
 184     }
 185
 186     if (part > D3D_BLOB_TEST_COMPILE_PERF
 187             || (part < D3D_BLOB_TEST_ALTERNATE_SHADER && part > D3D_BLOB_XNA_SHADER))
 188     {
 189         WARN("Invalid D3D_BLOB_PART: part %s\n", debug_d3dcompiler_d3d_blob_part(part));
 190         return D3DERR_INVALIDCALL;
 191     }
 192
 193     hr = dxbc_parse(data, data_size, &src_dxbc);
 194     if (FAILED(hr))
 195     {
 196         WARN("Failed to parse blob part\n");
 197         return hr;
 198     }
 199
 200     hr = dxbc_init(&dst_dxbc, 0);
 201     if (FAILED(hr))
 202     {
 203         dxbc_destroy(&src_dxbc);
 204         WARN("Failed to init dxbc\n");
 205         return hr;
 206     }
 207
 208     for (i = 0; i < src_dxbc.count; ++i)
 209     {
 210         struct dxbc_section *section = &src_dxbc.sections[i];
 211
 212         if (check_blob_part(section->tag, part))
 213         {
 214             hr = dxbc_add_section(&dst_dxbc, section->tag, section->data, section->data_size);
 215             if (FAILED(hr))
 216             {
 217                 dxbc_destroy(&src_dxbc);
 218                 dxbc_destroy(&dst_dxbc);
 219                 WARN("Failed to add section to dxbc\n");
 220                 return hr;
 221             }
 222         }
 223     }
 224
 225     count = dst_dxbc.count;
 226
 227     switch(part)
 228     {
 229         case D3D_BLOB_INPUT_SIGNATURE_BLOB:
 230         case D3D_BLOB_OUTPUT_SIGNATURE_BLOB:
 231         case D3D_BLOB_PATCH_CONSTANT_SIGNATURE_BLOB:
 232         case D3D_BLOB_DEBUG_INFO:
 233         case D3D_BLOB_LEGACY_SHADER:
 234         case D3D_BLOB_XNA_PREPASS_SHADER:
 235         case D3D_BLOB_XNA_SHADER:
 236             if (count != 1) count = 0;
 237             break;
 238
 239         case D3D_BLOB_INPUT_AND_OUTPUT_SIGNATURE_BLOB:
 240             if (count != 2) count = 0;
 241             break;
 242
 243         case D3D_BLOB_ALL_SIGNATURE_BLOB:
 244             if (count != 3) count = 0;
 245             break;
 246
 247         default:
 248             FIXME("Unhandled D3D_BLOB_PART %s.\n", debug_d3dcompiler_d3d_blob_part(part));
 249             break;
 250     }
 251
 252     if (count == 0)
 253     {
 254         dxbc_destroy(&src_dxbc);
 255         dxbc_destroy(&dst_dxbc);
 256         WARN("Nothing to write into the blob (count = 0)\n");
 257         return E_FAIL;
 258     }
 259
 260     /* some parts aren't full DXBCs, they contain only the data */
 261     if (count == 1 && (part == D3D_BLOB_DEBUG_INFO || part == D3D_BLOB_LEGACY_SHADER || part == D3D_BLOB_XNA_PREPASS_SHADER
 262             || part == D3D_BLOB_XNA_SHADER))
 263     {
 264         hr = D3DCreateBlob(dst_dxbc.sections[0].data_size, blob);
 265         if (SUCCEEDED(hr))
 266         {
 267             memcpy(ID3D10Blob_GetBufferPointer(*blob), dst_dxbc.sections[0].data, dst_dxbc.sections[0].data_size);
 268         }
 269         else
 270         {
 271             WARN("Could not create blob\n");
 272         }
 273     }
 274     else
 275     {
 276         hr = dxbc_write_blob(&dst_dxbc, blob);
 277         if (FAILED(hr))
 278         {
 279             WARN("Failed to write blob part\n");
 280         }
 281     }
 282
 283     dxbc_destroy(&src_dxbc);
 284     dxbc_destroy(&dst_dxbc);
 285
 286     return hr;
 287 }
 288
 289 static BOOL check_blob_strip(DWORD tag, UINT flags)
 290 {
 291     BOOL add = TRUE;
 292
 293     if (flags & D3DCOMPILER_STRIP_TEST_BLOBS) FIXME("Unhandled flag D3DCOMPILER_STRIP_TEST_BLOBS.\n");
 294
 295     switch(tag)
 296     {
 297         case TAG_RDEF:
 298         case TAG_STAT:
 299             if (flags & D3DCOMPILER_STRIP_REFLECTION_DATA) add = FALSE;
 300             break;
 301
 302         case TAG_SDBG:
 303             if (flags & D3DCOMPILER_STRIP_DEBUG_INFO) add = FALSE;
 304             break;
 305
 306         default:
 307             break;
 308     }
 309
 310     TRACE("%s tag %s\n", add ? "Add" : "Skip", debugstr_an((const char *)&tag, 4));
 311
 312     return add;
 313 }
 314
 315 HRESULT d3dcompiler_strip_shader(const void *data, SIZE_T data_size, UINT flags, ID3DBlob **blob)
 316 {
 317     struct dxbc src_dxbc, dst_dxbc;
 318     HRESULT hr;
 319     unsigned int i;
 320
 321     if (!blob)
 322     {
 323         WARN("NULL for blob specified\n");
 324         return E_FAIL;
 325     }
 326
 327     if (!data || !data_size)
 328     {
 329         WARN("Invalid arguments: data %p, data_size %lu\n", data, data_size);
 330         return D3DERR_INVALIDCALL;
 331     }
 332
 333     hr = dxbc_parse(data, data_size, &src_dxbc);
 334     if (FAILED(hr))
 335     {
 336         WARN("Failed to parse blob part\n");
 337         return hr;
 338     }
 339
 340     /* src_dxbc.count >= dst_dxbc.count */
 341     hr = dxbc_init(&dst_dxbc, src_dxbc.count);
 342     if (FAILED(hr))
 343     {
 344         dxbc_destroy(&src_dxbc);
 345         WARN("Failed to init dxbc\n");
 346         return hr;
 347     }
 348
 349     for (i = 0; i < src_dxbc.count; ++i)
 350     {
 351         struct dxbc_section *section = &src_dxbc.sections[i];
 352
 353         if (check_blob_strip(section->tag, flags))
 354         {
 355             hr = dxbc_add_section(&dst_dxbc, section->tag, section->data, section->data_size);
 356             if (FAILED(hr))
 357             {
 358                 dxbc_destroy(&src_dxbc);
 359                 dxbc_destroy(&dst_dxbc);
 360                 WARN("Failed to add section to dxbc\n");
 361                 return hr;
 362             }
 363         }
 364     }
 365
 366     hr = dxbc_write_blob(&dst_dxbc, blob);
 367     if (FAILED(hr))
 368     {
 369         WARN("Failed to write blob part\n");
 370     }
 371
 372     dxbc_destroy(&src_dxbc);
 373     dxbc_destroy(&dst_dxbc);
 374
 375     return hr;
 376 }