dlls/d3d11/shader.c

   1 /*
   2  * Copyright 2009 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 #include "d3d11_private.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  26
  27 static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *ctx)
  28 {
  29     struct d3d10_shader_info *shader_info = ctx;
  30     HRESULT hr;
  31
  32     switch (tag)
  33     {
  34         case TAG_ISGN:
  35             if (FAILED(hr = shader_parse_signature(data, data_size, shader_info->input_signature)))
  36                 return hr;
  37             break;
  38
  39         case TAG_OSGN:
  40             if (FAILED(hr = shader_parse_signature(data, data_size, shader_info->output_signature)))
  41                 return hr;
  42             break;
  43
  44         case TAG_SHDR:
  45             shader_info->shader_code = (const DWORD *)data;
  46             break;
  47
  48         default:
  49             FIXME("Unhandled chunk %s\n", debugstr_an((const char *)&tag, 4));
  50             break;
  51     }
  52
  53     return S_OK;
  54 }
  55
  56 static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length, struct d3d10_shader_info *shader_info)
  57 {
  58     HRESULT hr;
  59
  60     shader_info->shader_code = NULL;
  61     memset(shader_info->input_signature, 0, sizeof(*shader_info->input_signature));
  62     memset(shader_info->output_signature, 0, sizeof(*shader_info->output_signature));
  63
  64     hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, shader_info);
  65     if (!shader_info->shader_code) hr = E_INVALIDARG;
  66
  67     if (FAILED(hr))
  68     {
  69         ERR("Failed to parse shader, hr %#x\n", hr);
  70         shader_free_signature(shader_info->input_signature);
  71         shader_free_signature(shader_info->output_signature);
  72     }
  73
  74     return hr;
  75 }
  76
  77 HRESULT shader_parse_signature(const char *data, DWORD data_size, struct wined3d_shader_signature *s)
  78 {
  79     struct wined3d_shader_signature_element *e;
  80     const char *ptr = data;
  81     unsigned int i;
  82     DWORD count;
  83
  84     read_dword(&ptr, &count);
  85     TRACE("%u elements\n", count);
  86
  87     skip_dword_unknown(&ptr, 1);
  88
  89     e = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*e));
  90     if (!e)
  91     {
  92         ERR("Failed to allocate input signature memory.\n");
  93         return E_OUTOFMEMORY;
  94     }
  95
  96     for (i = 0; i < count; ++i)
  97     {
  98         UINT name_offset;
  99
 100         read_dword(&ptr, &name_offset);
 101         e[i].semantic_name = data + name_offset;
 102         read_dword(&ptr, &e[i].semantic_idx);
 103         read_dword(&ptr, &e[i].sysval_semantic);
 104         read_dword(&ptr, &e[i].component_type);
 105         read_dword(&ptr, &e[i].register_idx);
 106         read_dword(&ptr, &e[i].mask);
 107
 108         TRACE("semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 109                 "type %u, register idx: %u, use_mask %#x, input_mask %#x\n",
 110                 debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic,
 111                 e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
 112     }
 113
 114     s->elements = e;
 115     s->element_count = count;
 116
 117     return S_OK;
 118 }
 119
 120 void shader_free_signature(struct wined3d_shader_signature *s)
 121 {
 122     HeapFree(GetProcessHeap(), 0, s->elements);
 123 }
 124
 125 /* ID3D11VertexShader methods */
 126
 127 static inline struct d3d_vertex_shader *impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 128 {
 129     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D11VertexShader_iface);
 130 }
 131
 132 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_QueryInterface(ID3D11VertexShader *iface,
 133         REFIID riid, void **object)
 134 {
 135     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 136
 137     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 138
 139     if (IsEqualGUID(riid, &IID_ID3D11VertexShader)
 140             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 141             || IsEqualGUID(riid, &IID_IUnknown))
 142     {
 143         ID3D11VertexShader_AddRef(iface);
 144         *object = iface;
 145         return S_OK;
 146     }
 147
 148     if (IsEqualGUID(riid, &IID_ID3D10VertexShader)
 149             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 150     {
 151         IUnknown_AddRef(&shader->ID3D10VertexShader_iface);
 152         *object = &shader->ID3D10VertexShader_iface;
 153         return S_OK;
 154     }
 155
 156     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 157
 158     *object = NULL;
 159     return E_NOINTERFACE;
 160 }
 161
 162 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_AddRef(ID3D11VertexShader *iface)
 163 {
 164     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 165     ULONG refcount = InterlockedIncrement(&shader->refcount);
 166
 167     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 168
 169     if (refcount == 1)
 170     {
 171         ID3D11Device_AddRef(shader->device);
 172         wined3d_mutex_lock();
 173         wined3d_shader_incref(shader->wined3d_shader);
 174         wined3d_mutex_unlock();
 175     }
 176
 177     return refcount;
 178 }
 179
 180 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_Release(ID3D11VertexShader *iface)
 181 {
 182     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 183     ULONG refcount = InterlockedDecrement(&shader->refcount);
 184
 185     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 186
 187     if (!refcount)
 188     {
 189         ID3D11Device *device = shader->device;
 190
 191         wined3d_mutex_lock();
 192         wined3d_shader_decref(shader->wined3d_shader);
 193         wined3d_mutex_unlock();
 194         /* Release the device last, it may cause the wined3d device to be
 195          * destroyed. */
 196         ID3D11Device_Release(device);
 197     }
 198
 199     return refcount;
 200 }
 201
 202 static void STDMETHODCALLTYPE d3d11_vertex_shader_GetDevice(ID3D11VertexShader *iface,
 203         ID3D11Device **device)
 204 {
 205     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 206
 207     TRACE("iface %p, device %p.\n", iface, device);
 208
 209     *device = shader->device;
 210     ID3D11Device_AddRef(*device);
 211 }
 212
 213 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_GetPrivateData(ID3D11VertexShader *iface,
 214         REFGUID guid, UINT *data_size, void *data)
 215 {
 216     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 217
 218     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 219
 220     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 221 }
 222
 223 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateData(ID3D11VertexShader *iface,
 224         REFGUID guid, UINT data_size, const void *data)
 225 {
 226     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 227
 228     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 229
 230     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 231 }
 232
 233 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateDataInterface(ID3D11VertexShader *iface,
 234         REFGUID guid, const IUnknown *data)
 235 {
 236     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 237
 238     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 239
 240     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 241 }
 242
 243 static const struct ID3D11VertexShaderVtbl d3d11_vertex_shader_vtbl =
 244 {
 245     /* IUnknown methods */
 246     d3d11_vertex_shader_QueryInterface,
 247     d3d11_vertex_shader_AddRef,
 248     d3d11_vertex_shader_Release,
 249     /* ID3D11DeviceChild methods */
 250     d3d11_vertex_shader_GetDevice,
 251     d3d11_vertex_shader_GetPrivateData,
 252     d3d11_vertex_shader_SetPrivateData,
 253     d3d11_vertex_shader_SetPrivateDataInterface,
 254 };
 255
 256 /* ID3D10VertexShader methods */
 257
 258 static inline struct d3d_vertex_shader *impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 259 {
 260     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D10VertexShader_iface);
 261 }
 262
 263 /* IUnknown methods */
 264
 265 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_QueryInterface(ID3D10VertexShader *iface,
 266         REFIID riid, void **object)
 267 {
 268     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 269
 270     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 271
 272     return d3d11_vertex_shader_QueryInterface(&shader->ID3D11VertexShader_iface, riid, object);
 273 }
 274
 275 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *iface)
 276 {
 277     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 278
 279     TRACE("iface %p.\n", iface);
 280
 281     return d3d11_vertex_shader_AddRef(&shader->ID3D11VertexShader_iface);
 282 }
 283
 284 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *iface)
 285 {
 286     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 287
 288     TRACE("iface %p.\n", iface);
 289
 290     return d3d11_vertex_shader_Release(&shader->ID3D11VertexShader_iface);
 291 }
 292
 293 /* ID3D10DeviceChild methods */
 294
 295 static void STDMETHODCALLTYPE d3d10_vertex_shader_GetDevice(ID3D10VertexShader *iface, ID3D10Device **device)
 296 {
 297     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 298
 299     TRACE("iface %p, device %p.\n", iface, device);
 300
 301     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
 302 }
 303
 304 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_GetPrivateData(ID3D10VertexShader *iface,
 305         REFGUID guid, UINT *data_size, void *data)
 306 {
 307     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 308
 309     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 310             iface, debugstr_guid(guid), data_size, data);
 311
 312     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 313 }
 314
 315 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateData(ID3D10VertexShader *iface,
 316         REFGUID guid, UINT data_size, const void *data)
 317 {
 318     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 319
 320     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 321             iface, debugstr_guid(guid), data_size, data);
 322
 323     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 324 }
 325
 326 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateDataInterface(ID3D10VertexShader *iface,
 327         REFGUID guid, const IUnknown *data)
 328 {
 329     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 330
 331     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 332
 333     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 334 }
 335
 336 static const struct ID3D10VertexShaderVtbl d3d10_vertex_shader_vtbl =
 337 {
 338     /* IUnknown methods */
 339     d3d10_vertex_shader_QueryInterface,
 340     d3d10_vertex_shader_AddRef,
 341     d3d10_vertex_shader_Release,
 342     /* ID3D10DeviceChild methods */
 343     d3d10_vertex_shader_GetDevice,
 344     d3d10_vertex_shader_GetPrivateData,
 345     d3d10_vertex_shader_SetPrivateData,
 346     d3d10_vertex_shader_SetPrivateDataInterface,
 347 };
 348
 349 static void STDMETHODCALLTYPE d3d_vertex_shader_wined3d_object_destroyed(void *parent)
 350 {
 351     struct d3d_vertex_shader *shader = parent;
 352
 353     wined3d_private_store_cleanup(&shader->private_store);
 354     HeapFree(GetProcessHeap(), 0, parent);
 355 }
 356
 357 static const struct wined3d_parent_ops d3d_vertex_shader_wined3d_parent_ops =
 358 {
 359     d3d_vertex_shader_wined3d_object_destroyed,
 360 };
 361
 362 HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d3d_device *device,
 363         const void *byte_code, SIZE_T byte_code_length)
 364 {
 365     struct wined3d_shader_signature output_signature;
 366     struct wined3d_shader_signature input_signature;
 367     struct d3d10_shader_info shader_info;
 368     struct wined3d_shader_desc desc;
 369     HRESULT hr;
 370
 371     shader->ID3D11VertexShader_iface.lpVtbl = &d3d11_vertex_shader_vtbl;
 372     shader->ID3D10VertexShader_iface.lpVtbl = &d3d10_vertex_shader_vtbl;
 373     shader->refcount = 1;
 374     wined3d_mutex_lock();
 375     wined3d_private_store_init(&shader->private_store);
 376
 377     shader_info.input_signature = &input_signature;
 378     shader_info.output_signature = &output_signature;
 379     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info)))
 380     {
 381         ERR("Failed to extract shader, hr %#x.\n", hr);
 382         wined3d_private_store_cleanup(&shader->private_store);
 383         wined3d_mutex_unlock();
 384         return hr;
 385     }
 386
 387     desc.byte_code = shader_info.shader_code;
 388     desc.input_signature = &input_signature;
 389     desc.output_signature = &output_signature;
 390     desc.max_version = 4;
 391
 392     hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
 393             &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader);
 394     shader_free_signature(&input_signature);
 395     shader_free_signature(&output_signature);
 396     if (FAILED(hr))
 397     {
 398         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 399         wined3d_private_store_cleanup(&shader->private_store);
 400         wined3d_mutex_unlock();
 401         return E_INVALIDARG;
 402     }
 403     wined3d_mutex_unlock();
 404
 405     shader->device = &device->ID3D11Device_iface;
 406     ID3D11Device_AddRef(shader->device);
 407
 408     return S_OK;
 409 }
 410
 411 struct d3d_vertex_shader *unsafe_impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 412 {
 413     if (!iface)
 414         return NULL;
 415     assert(iface->lpVtbl == &d3d10_vertex_shader_vtbl);
 416
 417     return impl_from_ID3D10VertexShader(iface);
 418 }
 419
 420 static inline struct d3d10_geometry_shader *impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
 421 {
 422     return CONTAINING_RECORD(iface, struct d3d10_geometry_shader, ID3D10GeometryShader_iface);
 423 }
 424
 425 /* IUnknown methods */
 426
 427 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_QueryInterface(ID3D10GeometryShader *iface,
 428         REFIID riid, void **object)
 429 {
 430     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 431
 432     if (IsEqualGUID(riid, &IID_ID3D10GeometryShader)
 433             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 434             || IsEqualGUID(riid, &IID_IUnknown))
 435     {
 436         IUnknown_AddRef(iface);
 437         *object = iface;
 438         return S_OK;
 439     }
 440
 441     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 442
 443     *object = NULL;
 444     return E_NOINTERFACE;
 445 }
 446
 447 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_AddRef(ID3D10GeometryShader *iface)
 448 {
 449     struct d3d10_geometry_shader *This = impl_from_ID3D10GeometryShader(iface);
 450     ULONG refcount = InterlockedIncrement(&This->refcount);
 451
 452     TRACE("%p increasing refcount to %u\n", This, refcount);
 453
 454     return refcount;
 455 }
 456
 457 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShader *iface)
 458 {
 459     struct d3d10_geometry_shader *This = impl_from_ID3D10GeometryShader(iface);
 460     ULONG refcount = InterlockedDecrement(&This->refcount);
 461
 462     TRACE("%p decreasing refcount to %u\n", This, refcount);
 463
 464     if (!refcount)
 465     {
 466         wined3d_mutex_lock();
 467         wined3d_shader_decref(This->wined3d_shader);
 468         wined3d_mutex_unlock();
 469     }
 470
 471     return refcount;
 472 }
 473
 474 /* ID3D10DeviceChild methods */
 475
 476 static void STDMETHODCALLTYPE d3d10_geometry_shader_GetDevice(ID3D10GeometryShader *iface, ID3D10Device **device)
 477 {
 478     FIXME("iface %p, device %p stub!\n", iface, device);
 479 }
 480
 481 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_GetPrivateData(ID3D10GeometryShader *iface,
 482         REFGUID guid, UINT *data_size, void *data)
 483 {
 484     struct d3d10_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 485
 486     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 487             iface, debugstr_guid(guid), data_size, data);
 488
 489     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 490 }
 491
 492 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateData(ID3D10GeometryShader *iface,
 493         REFGUID guid, UINT data_size, const void *data)
 494 {
 495     struct d3d10_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 496
 497     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 498             iface, debugstr_guid(guid), data_size, data);
 499
 500     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 501 }
 502
 503 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateDataInterface(ID3D10GeometryShader *iface,
 504         REFGUID guid, const IUnknown *data)
 505 {
 506     struct d3d10_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
 507
 508     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 509
 510     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 511 }
 512
 513 static const struct ID3D10GeometryShaderVtbl d3d10_geometry_shader_vtbl =
 514 {
 515     /* IUnknown methods */
 516     d3d10_geometry_shader_QueryInterface,
 517     d3d10_geometry_shader_AddRef,
 518     d3d10_geometry_shader_Release,
 519     /* ID3D10DeviceChild methods */
 520     d3d10_geometry_shader_GetDevice,
 521     d3d10_geometry_shader_GetPrivateData,
 522     d3d10_geometry_shader_SetPrivateData,
 523     d3d10_geometry_shader_SetPrivateDataInterface,
 524 };
 525
 526 static void STDMETHODCALLTYPE d3d10_geometry_shader_wined3d_object_destroyed(void *parent)
 527 {
 528     struct d3d10_geometry_shader *shader = parent;
 529
 530     wined3d_private_store_cleanup(&shader->private_store);
 531     HeapFree(GetProcessHeap(), 0, parent);
 532 }
 533
 534 static const struct wined3d_parent_ops d3d10_geometry_shader_wined3d_parent_ops =
 535 {
 536     d3d10_geometry_shader_wined3d_object_destroyed,
 537 };
 538
 539 HRESULT d3d10_geometry_shader_init(struct d3d10_geometry_shader *shader, struct d3d_device *device,
 540         const void *byte_code, SIZE_T byte_code_length)
 541 {
 542     struct wined3d_shader_signature output_signature;
 543     struct wined3d_shader_signature input_signature;
 544     struct d3d10_shader_info shader_info;
 545     struct wined3d_shader_desc desc;
 546     HRESULT hr;
 547
 548     shader->ID3D10GeometryShader_iface.lpVtbl = &d3d10_geometry_shader_vtbl;
 549     shader->refcount = 1;
 550     wined3d_mutex_lock();
 551     wined3d_private_store_init(&shader->private_store);
 552
 553     shader_info.input_signature = &input_signature;
 554     shader_info.output_signature = &output_signature;
 555     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info)))
 556     {
 557         ERR("Failed to extract shader, hr %#x.\n", hr);
 558         wined3d_private_store_cleanup(&shader->private_store);
 559         wined3d_mutex_unlock();
 560         return hr;
 561     }
 562
 563     desc.byte_code = shader_info.shader_code;
 564     desc.input_signature = &input_signature;
 565     desc.output_signature = &output_signature;
 566     desc.max_version = 4;
 567
 568     hr = wined3d_shader_create_gs(device->wined3d_device, &desc, shader,
 569             &d3d10_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader);
 570     shader_free_signature(&input_signature);
 571     shader_free_signature(&output_signature);
 572     if (FAILED(hr))
 573     {
 574         WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr);
 575         wined3d_private_store_cleanup(&shader->private_store);
 576         wined3d_mutex_unlock();
 577         return E_INVALIDARG;
 578     }
 579     wined3d_mutex_unlock();
 580
 581     return S_OK;
 582 }
 583
 584 struct d3d10_geometry_shader *unsafe_impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
 585 {
 586     if (!iface)
 587         return NULL;
 588     assert(iface->lpVtbl == &d3d10_geometry_shader_vtbl);
 589
 590     return impl_from_ID3D10GeometryShader(iface);
 591 }
 592
 593 static inline struct d3d10_pixel_shader *impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
 594 {
 595     return CONTAINING_RECORD(iface, struct d3d10_pixel_shader, ID3D10PixelShader_iface);
 596 }
 597
 598 /* IUnknown methods */
 599
 600 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_QueryInterface(ID3D10PixelShader *iface,
 601         REFIID riid, void **object)
 602 {
 603     TRACE("iface %p, riid %s, object %p\n", iface, debugstr_guid(riid), object);
 604
 605     if (IsEqualGUID(riid, &IID_ID3D10PixelShader)
 606             || IsEqualGUID(riid, &IID_ID3D10DeviceChild)
 607             || IsEqualGUID(riid, &IID_IUnknown))
 608     {
 609         IUnknown_AddRef(iface);
 610         *object = iface;
 611         return S_OK;
 612     }
 613
 614     WARN("%s not implemented, returning E_NOINTERFACE\n", debugstr_guid(riid));
 615
 616     *object = NULL;
 617     return E_NOINTERFACE;
 618 }
 619
 620 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
 621 {
 622     struct d3d10_pixel_shader *This = impl_from_ID3D10PixelShader(iface);
 623     ULONG refcount = InterlockedIncrement(&This->refcount);
 624
 625     TRACE("%p increasing refcount to %u\n", This, refcount);
 626
 627     if (refcount == 1)
 628     {
 629         ID3D10Device1_AddRef(This->device);
 630         wined3d_mutex_lock();
 631         wined3d_shader_incref(This->wined3d_shader);
 632         wined3d_mutex_unlock();
 633     }
 634
 635     return refcount;
 636 }
 637
 638 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *iface)
 639 {
 640     struct d3d10_pixel_shader *This = impl_from_ID3D10PixelShader(iface);
 641     ULONG refcount = InterlockedDecrement(&This->refcount);
 642
 643     TRACE("%p decreasing refcount to %u\n", This, refcount);
 644
 645     if (!refcount)
 646     {
 647         ID3D10Device1 *device = This->device;
 648
 649         wined3d_mutex_lock();
 650         wined3d_shader_decref(This->wined3d_shader);
 651         wined3d_mutex_unlock();
 652         /* Release the device last, it may cause the wined3d device to be
 653          * destroyed. */
 654         ID3D10Device1_Release(device);
 655     }
 656
 657     return refcount;
 658 }
 659
 660 /* ID3D10DeviceChild methods */
 661
 662 static void STDMETHODCALLTYPE d3d10_pixel_shader_GetDevice(ID3D10PixelShader *iface, ID3D10Device **device)
 663 {
 664     struct d3d10_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
 665
 666     TRACE("iface %p, device %p.\n", iface, device);
 667
 668     *device = (ID3D10Device *)shader->device;
 669     ID3D10Device_AddRef(*device);
 670 }
 671
 672 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_GetPrivateData(ID3D10PixelShader *iface,
 673         REFGUID guid, UINT *data_size, void *data)
 674 {
 675     struct d3d10_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
 676
 677     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 678             iface, debugstr_guid(guid), data_size, data);
 679
 680     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 681 }
 682
 683 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateData(ID3D10PixelShader *iface,
 684         REFGUID guid, UINT data_size, const void *data)
 685 {
 686     struct d3d10_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
 687
 688     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 689             iface, debugstr_guid(guid), data_size, data);
 690
 691     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 692 }
 693
 694 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateDataInterface(ID3D10PixelShader *iface,
 695         REFGUID guid, const IUnknown *data)
 696 {
 697     struct d3d10_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
 698
 699     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 700
 701     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 702 }
 703
 704 static const struct ID3D10PixelShaderVtbl d3d10_pixel_shader_vtbl =
 705 {
 706     /* IUnknown methods */
 707     d3d10_pixel_shader_QueryInterface,
 708     d3d10_pixel_shader_AddRef,
 709     d3d10_pixel_shader_Release,
 710     /* ID3D10DeviceChild methods */
 711     d3d10_pixel_shader_GetDevice,
 712     d3d10_pixel_shader_GetPrivateData,
 713     d3d10_pixel_shader_SetPrivateData,
 714     d3d10_pixel_shader_SetPrivateDataInterface,
 715 };
 716
 717 static void STDMETHODCALLTYPE d3d10_pixel_shader_wined3d_object_destroyed(void *parent)
 718 {
 719     struct d3d10_pixel_shader *shader = parent;
 720
 721     wined3d_private_store_cleanup(&shader->private_store);
 722     HeapFree(GetProcessHeap(), 0, parent);
 723 }
 724
 725 static const struct wined3d_parent_ops d3d10_pixel_shader_wined3d_parent_ops =
 726 {
 727     d3d10_pixel_shader_wined3d_object_destroyed,
 728 };
 729
 730 HRESULT d3d10_pixel_shader_init(struct d3d10_pixel_shader *shader, struct d3d_device *device,
 731         const void *byte_code, SIZE_T byte_code_length)
 732 {
 733     struct wined3d_shader_signature output_signature;
 734     struct wined3d_shader_signature input_signature;
 735     struct d3d10_shader_info shader_info;
 736     struct wined3d_shader_desc desc;
 737     HRESULT hr;
 738
 739     shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
 740     shader->refcount = 1;
 741     wined3d_mutex_lock();
 742     wined3d_private_store_init(&shader->private_store);
 743
 744     shader_info.input_signature = &input_signature;
 745     shader_info.output_signature = &output_signature;
 746     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &shader_info)))
 747     {
 748         ERR("Failed to extract shader, hr %#x.\n", hr);
 749         wined3d_private_store_cleanup(&shader->private_store);
 750         wined3d_mutex_unlock();
 751         return hr;
 752     }
 753
 754     desc.byte_code = shader_info.shader_code;
 755     desc.input_signature = &input_signature;
 756     desc.output_signature = &output_signature;
 757     desc.max_version = 4;
 758
 759     hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
 760             &d3d10_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader);
 761     shader_free_signature(&input_signature);
 762     shader_free_signature(&output_signature);
 763     if (FAILED(hr))
 764     {
 765         WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
 766         wined3d_private_store_cleanup(&shader->private_store);
 767         wined3d_mutex_unlock();
 768         return E_INVALIDARG;
 769     }
 770     wined3d_mutex_unlock();
 771
 772     shader->device = &device->ID3D10Device1_iface;
 773     ID3D10Device1_AddRef(shader->device);
 774
 775     return S_OK;
 776 }
 777
 778 struct d3d10_pixel_shader *unsafe_impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
 779 {
 780     if (!iface)
 781         return NULL;
 782     assert(iface->lpVtbl == &d3d10_pixel_shader_vtbl);
 783
 784     return impl_from_ID3D10PixelShader(iface);
 785 }