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 struct aon9_header
  28 {
  29     DWORD chunk_size;
  30     DWORD shader_version;
  31     DWORD unknown;
  32     DWORD byte_code_offset;
  33 };
  34
  35 struct shader_handler_context
  36 {
  37     D3D_FEATURE_LEVEL feature_level;
  38     struct wined3d_shader_desc *desc;
  39 };
  40
  41 static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *context)
  42 {
  43     const struct shader_handler_context *ctx = context;
  44     struct wined3d_shader_desc *desc = ctx->desc;
  45     HRESULT hr;
  46
  47     switch (tag)
  48     {
  49         case TAG_ISGN:
  50             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  51             {
  52                 TRACE("Skipping shader input signature on feature level %#x.\n", ctx->feature_level);
  53                 break;
  54             }
  55             if (desc->input_signature.elements)
  56             {
  57                 FIXME("Multiple input signatures.\n");
  58                 break;
  59             }
  60             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->input_signature)))
  61                 return hr;
  62             break;
  63
  64         case TAG_OSGN:
  65         case TAG_OSG5:
  66             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  67             {
  68                 TRACE("Skipping shader output signature on feature level %#x.\n", ctx->feature_level);
  69                 break;
  70             }
  71             if (desc->output_signature.elements)
  72             {
  73                 FIXME("Multiple output signatures.\n");
  74                 break;
  75             }
  76             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->output_signature)))
  77                 return hr;
  78             break;
  79
  80         case TAG_PCSG:
  81             if (desc->patch_constant_signature.elements)
  82             {
  83                 FIXME("Multiple patch constant signatures.\n");
  84                 break;
  85             }
  86             if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->patch_constant_signature)))
  87                 return hr;
  88             break;
  89
  90         case TAG_SHDR:
  91         case TAG_SHEX:
  92             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
  93             {
  94                 TRACE("Skipping SM4+ shader code on feature level %#x.\n", ctx->feature_level);
  95                 break;
  96             }
  97             if (desc->byte_code)
  98                 FIXME("Multiple shader code chunks.\n");
  99             desc->byte_code = (const DWORD *)data;
 100             desc->byte_code_size = data_size;
 101             desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4;
 102             break;
 103
 104         case TAG_AON9:
 105             if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3)
 106             {
 107                 const struct aon9_header *header = (const struct aon9_header *)data;
 108                 unsigned int unknown_dword_count;
 109                 const char *byte_code;
 110
 111                 if (data_size < sizeof(*header))
 112                 {
 113                     WARN("Invalid Aon9 data size %#x.\n", data_size);
 114                     return E_FAIL;
 115                 }
 116                 byte_code = data + header->byte_code_offset;
 117                 unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD);
 118
 119                 if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset)
 120                 {
 121                     WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size);
 122                     return E_FAIL;
 123                 }
 124                 FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count);
 125
 126                 if (desc->byte_code)
 127                     FIXME("Multiple shader code chunks.\n");
 128                 desc->byte_code = (const DWORD *)byte_code;
 129                 desc->byte_code_size = data_size - header->byte_code_offset;
 130                 desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1;
 131                 TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", header->shader_version, *desc->byte_code);
 132             }
 133             else
 134             {
 135                 TRACE("Skipping feature level 9 shader code on feature level %#x.\n", ctx->feature_level);
 136             }
 137             break;
 138
 139         default:
 140             FIXME("Unhandled chunk %s.\n", debugstr_an((const char *)&tag, 4));
 141             break;
 142     }
 143
 144     return S_OK;
 145 }
 146
 147 static void free_shader_desc(struct wined3d_shader_desc *desc)
 148 {
 149     shader_free_signature(&desc->input_signature);
 150     shader_free_signature(&desc->output_signature);
 151     shader_free_signature(&desc->patch_constant_signature);
 152 }
 153
 154 static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length,
 155         struct wined3d_shader_desc *desc, D3D_FEATURE_LEVEL feature_level)
 156 {
 157     struct shader_handler_context ctx = {feature_level, desc};
 158     HRESULT hr;
 159
 160     desc->byte_code = NULL;
 161     desc->byte_code_size = 0;
 162     memset(&desc->input_signature, 0, sizeof(desc->input_signature));
 163     memset(&desc->output_signature, 0, sizeof(desc->output_signature));
 164     memset(&desc->patch_constant_signature, 0, sizeof(desc->patch_constant_signature));
 165
 166     hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, &ctx);
 167     if (!desc->byte_code)
 168         hr = E_INVALIDARG;
 169
 170     if (FAILED(hr))
 171     {
 172         FIXME("Failed to parse shader, hr %#x.\n", hr);
 173         free_shader_desc(desc);
 174     }
 175
 176     return hr;
 177 }
 178
 179 static const char *shader_get_string(const char *data, size_t data_size, DWORD offset)
 180 {
 181     size_t len, max_len;
 182
 183     if (offset >= data_size)
 184     {
 185         WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size);
 186         return NULL;
 187     }
 188
 189     max_len = data_size - offset;
 190     len = strnlen(data + offset, max_len);
 191
 192     if (len == max_len)
 193         return NULL;
 194
 195     return data + offset;
 196 }
 197
 198 HRESULT shader_parse_signature(DWORD tag, const char *data, DWORD data_size,
 199         struct wined3d_shader_signature *s)
 200 {
 201     struct wined3d_shader_signature_element *e;
 202     const char *ptr = data;
 203     unsigned int i;
 204     DWORD count;
 205
 206     if (!require_space(0, 2, sizeof(DWORD), data_size))
 207     {
 208         WARN("Invalid data size %#x.\n", data_size);
 209         return E_INVALIDARG;
 210     }
 211
 212     read_dword(&ptr, &count);
 213     TRACE("%u elements.\n", count);
 214
 215     skip_dword_unknown(&ptr, 1); /* It seems to always be 0x00000008. */
 216
 217     if (!require_space(ptr - data, count, 6 * sizeof(DWORD), data_size))
 218     {
 219         WARN("Invalid count %#x (data size %#x).\n", count, data_size);
 220         return E_INVALIDARG;
 221     }
 222
 223     if (!(e = d3d11_calloc(count, sizeof(*e))))
 224     {
 225         ERR("Failed to allocate input signature memory.\n");
 226         return E_OUTOFMEMORY;
 227     }
 228
 229     for (i = 0; i < count; ++i)
 230     {
 231         DWORD name_offset;
 232
 233         if (tag == TAG_OSG5)
 234             read_dword(&ptr, &e[i].stream_idx);
 235         else
 236             e[i].stream_idx = 0;
 237         read_dword(&ptr, &name_offset);
 238         if (!(e[i].semantic_name = shader_get_string(data, data_size, name_offset)))
 239         {
 240             WARN("Invalid name offset %#x (data size %#x).\n", name_offset, data_size);
 241             HeapFree(GetProcessHeap(), 0, e);
 242             return E_INVALIDARG;
 243         }
 244         read_dword(&ptr, &e[i].semantic_idx);
 245         read_dword(&ptr, &e[i].sysval_semantic);
 246         read_dword(&ptr, &e[i].component_type);
 247         read_dword(&ptr, &e[i].register_idx);
 248         read_dword(&ptr, &e[i].mask);
 249
 250         TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, "
 251                 "type %u, register idx: %u, use_mask %#x, input_mask %#x.\n",
 252                 e[i].stream_idx, debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic,
 253                 e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff);
 254     }
 255
 256     s->elements = e;
 257     s->element_count = count;
 258
 259     return S_OK;
 260 }
 261
 262 struct wined3d_shader_signature_element *shader_find_signature_element(const struct wined3d_shader_signature *s,
 263         const char *semantic_name, unsigned int semantic_idx, unsigned int stream_idx)
 264 {
 265     struct wined3d_shader_signature_element *e = s->elements;
 266     unsigned int i;
 267
 268     for (i = 0; i < s->element_count; ++i)
 269     {
 270         if (!strcasecmp(e[i].semantic_name, semantic_name) && e[i].semantic_idx == semantic_idx
 271                 && e[i].stream_idx == stream_idx)
 272             return &e[i];
 273     }
 274
 275     return NULL;
 276 }
 277
 278 void shader_free_signature(struct wined3d_shader_signature *s)
 279 {
 280     HeapFree(GetProcessHeap(), 0, s->elements);
 281 }
 282
 283 /* ID3D11VertexShader methods */
 284
 285 static inline struct d3d_vertex_shader *impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 286 {
 287     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D11VertexShader_iface);
 288 }
 289
 290 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_QueryInterface(ID3D11VertexShader *iface,
 291         REFIID riid, void **object)
 292 {
 293     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 294
 295     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 296
 297     if (IsEqualGUID(riid, &IID_ID3D11VertexShader)
 298             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 299             || IsEqualGUID(riid, &IID_IUnknown))
 300     {
 301         ID3D11VertexShader_AddRef(iface);
 302         *object = iface;
 303         return S_OK;
 304     }
 305
 306     if (IsEqualGUID(riid, &IID_ID3D10VertexShader)
 307             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 308     {
 309         IUnknown_AddRef(&shader->ID3D10VertexShader_iface);
 310         *object = &shader->ID3D10VertexShader_iface;
 311         return S_OK;
 312     }
 313
 314     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 315
 316     *object = NULL;
 317     return E_NOINTERFACE;
 318 }
 319
 320 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_AddRef(ID3D11VertexShader *iface)
 321 {
 322     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 323     ULONG refcount = InterlockedIncrement(&shader->refcount);
 324
 325     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 326
 327     if (refcount == 1)
 328     {
 329         ID3D11Device_AddRef(shader->device);
 330         wined3d_mutex_lock();
 331         wined3d_shader_incref(shader->wined3d_shader);
 332         wined3d_mutex_unlock();
 333     }
 334
 335     return refcount;
 336 }
 337
 338 static ULONG STDMETHODCALLTYPE d3d11_vertex_shader_Release(ID3D11VertexShader *iface)
 339 {
 340     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 341     ULONG refcount = InterlockedDecrement(&shader->refcount);
 342
 343     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 344
 345     if (!refcount)
 346     {
 347         ID3D11Device *device = shader->device;
 348
 349         wined3d_mutex_lock();
 350         wined3d_shader_decref(shader->wined3d_shader);
 351         wined3d_mutex_unlock();
 352         /* Release the device last, it may cause the wined3d device to be
 353          * destroyed. */
 354         ID3D11Device_Release(device);
 355     }
 356
 357     return refcount;
 358 }
 359
 360 static void STDMETHODCALLTYPE d3d11_vertex_shader_GetDevice(ID3D11VertexShader *iface,
 361         ID3D11Device **device)
 362 {
 363     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 364
 365     TRACE("iface %p, device %p.\n", iface, device);
 366
 367     *device = shader->device;
 368     ID3D11Device_AddRef(*device);
 369 }
 370
 371 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_GetPrivateData(ID3D11VertexShader *iface,
 372         REFGUID guid, UINT *data_size, void *data)
 373 {
 374     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 375
 376     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 377
 378     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 379 }
 380
 381 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateData(ID3D11VertexShader *iface,
 382         REFGUID guid, UINT data_size, const void *data)
 383 {
 384     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 385
 386     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 387
 388     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 389 }
 390
 391 static HRESULT STDMETHODCALLTYPE d3d11_vertex_shader_SetPrivateDataInterface(ID3D11VertexShader *iface,
 392         REFGUID guid, const IUnknown *data)
 393 {
 394     struct d3d_vertex_shader *shader = impl_from_ID3D11VertexShader(iface);
 395
 396     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 397
 398     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 399 }
 400
 401 static const struct ID3D11VertexShaderVtbl d3d11_vertex_shader_vtbl =
 402 {
 403     /* IUnknown methods */
 404     d3d11_vertex_shader_QueryInterface,
 405     d3d11_vertex_shader_AddRef,
 406     d3d11_vertex_shader_Release,
 407     /* ID3D11DeviceChild methods */
 408     d3d11_vertex_shader_GetDevice,
 409     d3d11_vertex_shader_GetPrivateData,
 410     d3d11_vertex_shader_SetPrivateData,
 411     d3d11_vertex_shader_SetPrivateDataInterface,
 412 };
 413
 414 /* ID3D10VertexShader methods */
 415
 416 static inline struct d3d_vertex_shader *impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 417 {
 418     return CONTAINING_RECORD(iface, struct d3d_vertex_shader, ID3D10VertexShader_iface);
 419 }
 420
 421 /* IUnknown methods */
 422
 423 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_QueryInterface(ID3D10VertexShader *iface,
 424         REFIID riid, void **object)
 425 {
 426     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 427
 428     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 429
 430     return d3d11_vertex_shader_QueryInterface(&shader->ID3D11VertexShader_iface, riid, object);
 431 }
 432
 433 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_AddRef(ID3D10VertexShader *iface)
 434 {
 435     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 436
 437     TRACE("iface %p.\n", iface);
 438
 439     return d3d11_vertex_shader_AddRef(&shader->ID3D11VertexShader_iface);
 440 }
 441
 442 static ULONG STDMETHODCALLTYPE d3d10_vertex_shader_Release(ID3D10VertexShader *iface)
 443 {
 444     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 445
 446     TRACE("iface %p.\n", iface);
 447
 448     return d3d11_vertex_shader_Release(&shader->ID3D11VertexShader_iface);
 449 }
 450
 451 /* ID3D10DeviceChild methods */
 452
 453 static void STDMETHODCALLTYPE d3d10_vertex_shader_GetDevice(ID3D10VertexShader *iface, ID3D10Device **device)
 454 {
 455     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 456
 457     TRACE("iface %p, device %p.\n", iface, device);
 458
 459     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
 460 }
 461
 462 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_GetPrivateData(ID3D10VertexShader *iface,
 463         REFGUID guid, UINT *data_size, void *data)
 464 {
 465     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 466
 467     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
 468             iface, debugstr_guid(guid), data_size, data);
 469
 470     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 471 }
 472
 473 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateData(ID3D10VertexShader *iface,
 474         REFGUID guid, UINT data_size, const void *data)
 475 {
 476     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 477
 478     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
 479             iface, debugstr_guid(guid), data_size, data);
 480
 481     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 482 }
 483
 484 static HRESULT STDMETHODCALLTYPE d3d10_vertex_shader_SetPrivateDataInterface(ID3D10VertexShader *iface,
 485         REFGUID guid, const IUnknown *data)
 486 {
 487     struct d3d_vertex_shader *shader = impl_from_ID3D10VertexShader(iface);
 488
 489     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 490
 491     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 492 }
 493
 494 static const struct ID3D10VertexShaderVtbl d3d10_vertex_shader_vtbl =
 495 {
 496     /* IUnknown methods */
 497     d3d10_vertex_shader_QueryInterface,
 498     d3d10_vertex_shader_AddRef,
 499     d3d10_vertex_shader_Release,
 500     /* ID3D10DeviceChild methods */
 501     d3d10_vertex_shader_GetDevice,
 502     d3d10_vertex_shader_GetPrivateData,
 503     d3d10_vertex_shader_SetPrivateData,
 504     d3d10_vertex_shader_SetPrivateDataInterface,
 505 };
 506
 507 static void STDMETHODCALLTYPE d3d_vertex_shader_wined3d_object_destroyed(void *parent)
 508 {
 509     struct d3d_vertex_shader *shader = parent;
 510
 511     wined3d_private_store_cleanup(&shader->private_store);
 512     HeapFree(GetProcessHeap(), 0, parent);
 513 }
 514
 515 static const struct wined3d_parent_ops d3d_vertex_shader_wined3d_parent_ops =
 516 {
 517     d3d_vertex_shader_wined3d_object_destroyed,
 518 };
 519
 520 static unsigned int d3d_sm_from_feature_level(D3D_FEATURE_LEVEL feature_level)
 521 {
 522     switch (feature_level)
 523     {
 524         case D3D_FEATURE_LEVEL_11_1:
 525         case D3D_FEATURE_LEVEL_11_0:
 526             return 5;
 527         case D3D_FEATURE_LEVEL_10_1:
 528         case D3D_FEATURE_LEVEL_10_0:
 529             return 4;
 530         case D3D_FEATURE_LEVEL_9_3:
 531             return 3;
 532         case D3D_FEATURE_LEVEL_9_2:
 533         case D3D_FEATURE_LEVEL_9_1:
 534             return 2;
 535         default:
 536             ERR("Unexpected feature_level %#x.\n", feature_level);
 537     }
 538     return 0;
 539 }
 540
 541 static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d3d_device *device,
 542         const void *byte_code, SIZE_T byte_code_length)
 543 {
 544     struct wined3d_shader_desc desc;
 545     HRESULT hr;
 546
 547     shader->ID3D11VertexShader_iface.lpVtbl = &d3d11_vertex_shader_vtbl;
 548     shader->ID3D10VertexShader_iface.lpVtbl = &d3d10_vertex_shader_vtbl;
 549     shader->refcount = 1;
 550     wined3d_mutex_lock();
 551     wined3d_private_store_init(&shader->private_store);
 552
 553     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 554     {
 555         WARN("Failed to extract shader, hr %#x.\n", hr);
 556         wined3d_private_store_cleanup(&shader->private_store);
 557         wined3d_mutex_unlock();
 558         return hr;
 559     }
 560     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 561
 562     hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader,
 563             &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader);
 564     free_shader_desc(&desc);
 565     if (FAILED(hr))
 566     {
 567         WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr);
 568         wined3d_private_store_cleanup(&shader->private_store);
 569         wined3d_mutex_unlock();
 570         return E_INVALIDARG;
 571     }
 572     wined3d_mutex_unlock();
 573
 574     shader->device = &device->ID3D11Device_iface;
 575     ID3D11Device_AddRef(shader->device);
 576
 577     return S_OK;
 578 }
 579
 580 HRESULT d3d_vertex_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 581         struct d3d_vertex_shader **shader)
 582 {
 583     struct d3d_vertex_shader *object;
 584     HRESULT hr;
 585
 586     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 587         return E_OUTOFMEMORY;
 588
 589     if (FAILED(hr = d3d_vertex_shader_init(object, device, byte_code, byte_code_length)))
 590     {
 591         WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
 592         HeapFree(GetProcessHeap(), 0, object);
 593         return hr;
 594     }
 595
 596     TRACE("Created vertex shader %p.\n", object);
 597     *shader = object;
 598
 599     return S_OK;
 600 }
 601
 602 struct d3d_vertex_shader *unsafe_impl_from_ID3D11VertexShader(ID3D11VertexShader *iface)
 603 {
 604     if (!iface)
 605         return NULL;
 606     assert(iface->lpVtbl == &d3d11_vertex_shader_vtbl);
 607
 608     return impl_from_ID3D11VertexShader(iface);
 609 }
 610
 611 struct d3d_vertex_shader *unsafe_impl_from_ID3D10VertexShader(ID3D10VertexShader *iface)
 612 {
 613     if (!iface)
 614         return NULL;
 615     assert(iface->lpVtbl == &d3d10_vertex_shader_vtbl);
 616
 617     return impl_from_ID3D10VertexShader(iface);
 618 }
 619
 620 /* ID3D11HullShader methods */
 621
 622 static inline struct d3d11_hull_shader *impl_from_ID3D11HullShader(ID3D11HullShader *iface)
 623 {
 624     return CONTAINING_RECORD(iface, struct d3d11_hull_shader, ID3D11HullShader_iface);
 625 }
 626
 627 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_QueryInterface(ID3D11HullShader *iface,
 628         REFIID riid, void **object)
 629 {
 630     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 631
 632     if (IsEqualGUID(riid, &IID_ID3D11HullShader)
 633             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 634             || IsEqualGUID(riid, &IID_IUnknown))
 635     {
 636         ID3D11HullShader_AddRef(iface);
 637         *object = iface;
 638         return S_OK;
 639     }
 640
 641     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 642
 643     *object = NULL;
 644     return E_NOINTERFACE;
 645 }
 646
 647 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_AddRef(ID3D11HullShader *iface)
 648 {
 649     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 650     ULONG refcount = InterlockedIncrement(&shader->refcount);
 651
 652     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 653
 654     if (refcount == 1)
 655     {
 656         ID3D11Device_AddRef(shader->device);
 657         wined3d_mutex_lock();
 658         wined3d_shader_incref(shader->wined3d_shader);
 659         wined3d_mutex_unlock();
 660     }
 661
 662     return refcount;
 663 }
 664
 665 static ULONG STDMETHODCALLTYPE d3d11_hull_shader_Release(ID3D11HullShader *iface)
 666 {
 667     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 668     ULONG refcount = InterlockedDecrement(&shader->refcount);
 669
 670     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 671
 672     if (!refcount)
 673     {
 674         ID3D11Device *device = shader->device;
 675
 676         wined3d_mutex_lock();
 677         wined3d_shader_decref(shader->wined3d_shader);
 678         wined3d_mutex_unlock();
 679
 680         /* Release the device last, it may cause the wined3d device to be
 681          * destroyed. */
 682         ID3D11Device_Release(device);
 683     }
 684
 685     return refcount;
 686 }
 687
 688 static void STDMETHODCALLTYPE d3d11_hull_shader_GetDevice(ID3D11HullShader *iface,
 689         ID3D11Device **device)
 690 {
 691     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 692
 693     TRACE("iface %p, device %p.\n", iface, device);
 694
 695     *device = shader->device;
 696     ID3D11Device_AddRef(*device);
 697 }
 698
 699 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_GetPrivateData(ID3D11HullShader *iface,
 700         REFGUID guid, UINT *data_size, void *data)
 701 {
 702     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 703
 704     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 705
 706     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 707 }
 708
 709 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateData(ID3D11HullShader *iface,
 710         REFGUID guid, UINT data_size, const void *data)
 711 {
 712     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 713
 714     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 715
 716     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 717 }
 718
 719 static HRESULT STDMETHODCALLTYPE d3d11_hull_shader_SetPrivateDataInterface(ID3D11HullShader *iface,
 720         REFGUID guid, const IUnknown *data)
 721 {
 722     struct d3d11_hull_shader *shader = impl_from_ID3D11HullShader(iface);
 723
 724     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 725
 726     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 727 }
 728
 729 static const struct ID3D11HullShaderVtbl d3d11_hull_shader_vtbl =
 730 {
 731     /* IUnknown methods */
 732     d3d11_hull_shader_QueryInterface,
 733     d3d11_hull_shader_AddRef,
 734     d3d11_hull_shader_Release,
 735     /* ID3D11DeviceChild methods */
 736     d3d11_hull_shader_GetDevice,
 737     d3d11_hull_shader_GetPrivateData,
 738     d3d11_hull_shader_SetPrivateData,
 739     d3d11_hull_shader_SetPrivateDataInterface,
 740 };
 741
 742 static void STDMETHODCALLTYPE d3d11_hull_shader_wined3d_object_destroyed(void *parent)
 743 {
 744     struct d3d11_hull_shader *shader = parent;
 745
 746     wined3d_private_store_cleanup(&shader->private_store);
 747     HeapFree(GetProcessHeap(), 0, parent);
 748 }
 749
 750 static const struct wined3d_parent_ops d3d11_hull_shader_wined3d_parent_ops =
 751 {
 752     d3d11_hull_shader_wined3d_object_destroyed,
 753 };
 754
 755 static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d3d_device *device,
 756         const void *byte_code, SIZE_T byte_code_length)
 757 {
 758     struct wined3d_shader_desc desc;
 759     HRESULT hr;
 760
 761     shader->ID3D11HullShader_iface.lpVtbl = &d3d11_hull_shader_vtbl;
 762     shader->refcount = 1;
 763     wined3d_mutex_lock();
 764     wined3d_private_store_init(&shader->private_store);
 765
 766     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 767     {
 768         WARN("Failed to extract shader, hr %#x.\n", hr);
 769         wined3d_private_store_cleanup(&shader->private_store);
 770         wined3d_mutex_unlock();
 771         return hr;
 772     }
 773     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 774
 775     hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader,
 776             &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader);
 777     free_shader_desc(&desc);
 778     if (FAILED(hr))
 779     {
 780         WARN("Failed to create wined3d hull shader, hr %#x.\n", hr);
 781         wined3d_private_store_cleanup(&shader->private_store);
 782         wined3d_mutex_unlock();
 783         return E_INVALIDARG;
 784     }
 785     wined3d_mutex_unlock();
 786
 787     shader->device = &device->ID3D11Device_iface;
 788     ID3D11Device_AddRef(shader->device);
 789
 790     return S_OK;
 791 }
 792
 793 HRESULT d3d11_hull_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 794         struct d3d11_hull_shader **shader)
 795 {
 796     struct d3d11_hull_shader *object;
 797     HRESULT hr;
 798
 799     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
 800         return E_OUTOFMEMORY;
 801
 802     if (FAILED(hr = d3d11_hull_shader_init(object, device, byte_code, byte_code_length)))
 803     {
 804         HeapFree(GetProcessHeap(), 0, object);
 805         return hr;
 806     }
 807
 808     TRACE("Created hull shader %p.\n", object);
 809     *shader = object;
 810
 811     return S_OK;
 812 }
 813
 814 struct d3d11_hull_shader *unsafe_impl_from_ID3D11HullShader(ID3D11HullShader *iface)
 815 {
 816     if (!iface)
 817         return NULL;
 818     assert(iface->lpVtbl == &d3d11_hull_shader_vtbl);
 819
 820     return impl_from_ID3D11HullShader(iface);
 821 }
 822
 823 /* ID3D11DomainShader methods */
 824
 825 static inline struct d3d11_domain_shader *impl_from_ID3D11DomainShader(ID3D11DomainShader *iface)
 826 {
 827     return CONTAINING_RECORD(iface, struct d3d11_domain_shader, ID3D11DomainShader_iface);
 828 }
 829
 830 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_QueryInterface(ID3D11DomainShader *iface,
 831         REFIID riid, void **object)
 832 {
 833     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 834
 835     if (IsEqualGUID(riid, &IID_ID3D11DomainShader)
 836             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 837             || IsEqualGUID(riid, &IID_IUnknown))
 838     {
 839         ID3D11DomainShader_AddRef(iface);
 840         *object = iface;
 841         return S_OK;
 842     }
 843
 844     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 845
 846     *object = NULL;
 847     return E_NOINTERFACE;
 848 }
 849
 850 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_AddRef(ID3D11DomainShader *iface)
 851 {
 852     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 853     ULONG refcount = InterlockedIncrement(&shader->refcount);
 854
 855     TRACE("%p increasing refcount to %u.\n", shader, refcount);
 856
 857     if (refcount == 1)
 858     {
 859         ID3D11Device_AddRef(shader->device);
 860         wined3d_mutex_lock();
 861         wined3d_shader_incref(shader->wined3d_shader);
 862         wined3d_mutex_unlock();
 863     }
 864
 865     return refcount;
 866 }
 867
 868 static ULONG STDMETHODCALLTYPE d3d11_domain_shader_Release(ID3D11DomainShader *iface)
 869 {
 870     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 871     ULONG refcount = InterlockedDecrement(&shader->refcount);
 872
 873     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
 874
 875     if (!refcount)
 876     {
 877         ID3D11Device *device = shader->device;
 878
 879         wined3d_mutex_lock();
 880         wined3d_shader_decref(shader->wined3d_shader);
 881         wined3d_mutex_unlock();
 882
 883         /* Release the device last, it may cause the wined3d device to be
 884          * destroyed. */
 885         ID3D11Device_Release(device);
 886     }
 887
 888     return refcount;
 889 }
 890
 891 static void STDMETHODCALLTYPE d3d11_domain_shader_GetDevice(ID3D11DomainShader *iface,
 892         ID3D11Device **device)
 893 {
 894     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 895
 896     TRACE("iface %p, device %p.\n", iface, device);
 897
 898     *device = shader->device;
 899     ID3D11Device_AddRef(*device);
 900 }
 901
 902 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_GetPrivateData(ID3D11DomainShader *iface,
 903         REFGUID guid, UINT *data_size, void *data)
 904 {
 905     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 906
 907     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 908
 909     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
 910 }
 911
 912 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateData(ID3D11DomainShader *iface,
 913         REFGUID guid, UINT data_size, const void *data)
 914 {
 915     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 916
 917     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
 918
 919     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
 920 }
 921
 922 static HRESULT STDMETHODCALLTYPE d3d11_domain_shader_SetPrivateDataInterface(ID3D11DomainShader *iface,
 923         REFGUID guid, const IUnknown *data)
 924 {
 925     struct d3d11_domain_shader *shader = impl_from_ID3D11DomainShader(iface);
 926
 927     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
 928
 929     return d3d_set_private_data_interface(&shader->private_store, guid, data);
 930 }
 931
 932 static const struct ID3D11DomainShaderVtbl d3d11_domain_shader_vtbl =
 933 {
 934     /* IUnknown methods */
 935     d3d11_domain_shader_QueryInterface,
 936     d3d11_domain_shader_AddRef,
 937     d3d11_domain_shader_Release,
 938     /* ID3D11DeviceChild methods */
 939     d3d11_domain_shader_GetDevice,
 940     d3d11_domain_shader_GetPrivateData,
 941     d3d11_domain_shader_SetPrivateData,
 942     d3d11_domain_shader_SetPrivateDataInterface,
 943 };
 944
 945 static void STDMETHODCALLTYPE d3d11_domain_shader_wined3d_object_destroyed(void *parent)
 946 {
 947     struct d3d11_domain_shader *shader = parent;
 948
 949     wined3d_private_store_cleanup(&shader->private_store);
 950     HeapFree(GetProcessHeap(), 0, parent);
 951 }
 952
 953 static const struct wined3d_parent_ops d3d11_domain_shader_wined3d_parent_ops =
 954 {
 955     d3d11_domain_shader_wined3d_object_destroyed,
 956 };
 957
 958 static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, struct d3d_device *device,
 959         const void *byte_code, SIZE_T byte_code_length)
 960 {
 961     struct wined3d_shader_desc desc;
 962     HRESULT hr;
 963
 964     shader->ID3D11DomainShader_iface.lpVtbl = &d3d11_domain_shader_vtbl;
 965     shader->refcount = 1;
 966     wined3d_mutex_lock();
 967     wined3d_private_store_init(&shader->private_store);
 968
 969     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
 970     {
 971         WARN("Failed to extract shader, hr %#x.\n", hr);
 972         wined3d_private_store_cleanup(&shader->private_store);
 973         wined3d_mutex_unlock();
 974         return hr;
 975     }
 976     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
 977
 978     hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader,
 979             &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader);
 980     free_shader_desc(&desc);
 981     if (FAILED(hr))
 982     {
 983         WARN("Failed to create wined3d domain shader, hr %#x.\n", hr);
 984         wined3d_private_store_cleanup(&shader->private_store);
 985         wined3d_mutex_unlock();
 986         return E_INVALIDARG;
 987     }
 988     wined3d_mutex_unlock();
 989
 990     shader->device = &device->ID3D11Device_iface;
 991     ID3D11Device_AddRef(shader->device);
 992
 993     return S_OK;
 994 }
 995
 996 HRESULT d3d11_domain_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
 997         struct d3d11_domain_shader **shader)
 998 {
 999     struct d3d11_domain_shader *object;
1000     HRESULT hr;
1001
1002     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1003         return E_OUTOFMEMORY;
1004
1005     if (FAILED(hr = d3d11_domain_shader_init(object, device, byte_code, byte_code_length)))
1006     {
1007         HeapFree(GetProcessHeap(), 0, object);
1008         return hr;
1009     }
1010
1011     TRACE("Created domain shader %p.\n", object);
1012     *shader = object;
1013
1014     return S_OK;
1015 }
1016
1017 struct d3d11_domain_shader *unsafe_impl_from_ID3D11DomainShader(ID3D11DomainShader *iface)
1018 {
1019     if (!iface)
1020         return NULL;
1021     assert(iface->lpVtbl == &d3d11_domain_shader_vtbl);
1022
1023     return impl_from_ID3D11DomainShader(iface);
1024 }
1025
1026 /* ID3D11GeometryShader methods */
1027
1028 static inline struct d3d_geometry_shader *impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
1029 {
1030     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D11GeometryShader_iface);
1031 }
1032
1033 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_QueryInterface(ID3D11GeometryShader *iface,
1034         REFIID riid, void **object)
1035 {
1036     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1037
1038     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1039
1040     if (IsEqualGUID(riid, &IID_ID3D11GeometryShader)
1041             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1042             || IsEqualGUID(riid, &IID_IUnknown))
1043     {
1044         ID3D11GeometryShader_AddRef(iface);
1045         *object = iface;
1046         return S_OK;
1047     }
1048
1049     if (IsEqualGUID(riid, &IID_ID3D10GeometryShader)
1050             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1051     {
1052         ID3D10GeometryShader_AddRef(&shader->ID3D10GeometryShader_iface);
1053         *object = &shader->ID3D10GeometryShader_iface;
1054         return S_OK;
1055     }
1056
1057     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1058
1059     *object = NULL;
1060     return E_NOINTERFACE;
1061 }
1062
1063 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_AddRef(ID3D11GeometryShader *iface)
1064 {
1065     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1066     ULONG refcount = InterlockedIncrement(&shader->refcount);
1067
1068     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1069
1070     if (refcount == 1)
1071     {
1072         ID3D11Device_AddRef(shader->device);
1073         wined3d_mutex_lock();
1074         wined3d_shader_incref(shader->wined3d_shader);
1075         wined3d_mutex_unlock();
1076     }
1077
1078     return refcount;
1079 }
1080
1081 static ULONG STDMETHODCALLTYPE d3d11_geometry_shader_Release(ID3D11GeometryShader *iface)
1082 {
1083     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1084     ULONG refcount = InterlockedDecrement(&shader->refcount);
1085
1086     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1087
1088     if (!refcount)
1089     {
1090         ID3D11Device *device = shader->device;
1091
1092         wined3d_mutex_lock();
1093         wined3d_shader_decref(shader->wined3d_shader);
1094         wined3d_mutex_unlock();
1095
1096         /* Release the device last, it may cause the wined3d device to be
1097          * destroyed. */
1098         ID3D11Device_Release(device);
1099     }
1100
1101     return refcount;
1102 }
1103
1104 static void STDMETHODCALLTYPE d3d11_geometry_shader_GetDevice(ID3D11GeometryShader *iface,
1105         ID3D11Device **device)
1106 {
1107     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1108
1109     TRACE("iface %p, device %p.\n", iface, device);
1110
1111     *device = shader->device;
1112     ID3D11Device_AddRef(*device);
1113 }
1114
1115 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_GetPrivateData(ID3D11GeometryShader *iface,
1116         REFGUID guid, UINT *data_size, void *data)
1117 {
1118     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1119
1120     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1121
1122     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1123 }
1124
1125 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateData(ID3D11GeometryShader *iface,
1126         REFGUID guid, UINT data_size, const void *data)
1127 {
1128     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1129
1130     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1131
1132     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1133 }
1134
1135 static HRESULT STDMETHODCALLTYPE d3d11_geometry_shader_SetPrivateDataInterface(ID3D11GeometryShader *iface,
1136         REFGUID guid, const IUnknown *data)
1137 {
1138     struct d3d_geometry_shader *shader = impl_from_ID3D11GeometryShader(iface);
1139
1140     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1141
1142     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1143 }
1144
1145 static const struct ID3D11GeometryShaderVtbl d3d11_geometry_shader_vtbl =
1146 {
1147     /* IUnknown methods */
1148     d3d11_geometry_shader_QueryInterface,
1149     d3d11_geometry_shader_AddRef,
1150     d3d11_geometry_shader_Release,
1151     /* ID3D11DeviceChild methods */
1152     d3d11_geometry_shader_GetDevice,
1153     d3d11_geometry_shader_GetPrivateData,
1154     d3d11_geometry_shader_SetPrivateData,
1155     d3d11_geometry_shader_SetPrivateDataInterface,
1156 };
1157
1158 /* ID3D10GeometryShader methods */
1159
1160 static inline struct d3d_geometry_shader *impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
1161 {
1162     return CONTAINING_RECORD(iface, struct d3d_geometry_shader, ID3D10GeometryShader_iface);
1163 }
1164
1165 /* IUnknown methods */
1166
1167 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_QueryInterface(ID3D10GeometryShader *iface,
1168         REFIID riid, void **object)
1169 {
1170     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1171
1172     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1173
1174     return d3d11_geometry_shader_QueryInterface(&shader->ID3D11GeometryShader_iface, riid, object);
1175 }
1176
1177 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_AddRef(ID3D10GeometryShader *iface)
1178 {
1179     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1180
1181     TRACE("iface %p.\n", iface);
1182
1183     return d3d11_geometry_shader_AddRef(&shader->ID3D11GeometryShader_iface);
1184 }
1185
1186 static ULONG STDMETHODCALLTYPE d3d10_geometry_shader_Release(ID3D10GeometryShader *iface)
1187 {
1188     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1189
1190     TRACE("iface %p.\n", iface);
1191
1192     return d3d11_geometry_shader_Release(&shader->ID3D11GeometryShader_iface);
1193 }
1194
1195 /* ID3D10DeviceChild methods */
1196
1197 static void STDMETHODCALLTYPE d3d10_geometry_shader_GetDevice(ID3D10GeometryShader *iface, ID3D10Device **device)
1198 {
1199     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1200
1201     TRACE("iface %p, device %p.\n", iface, device);
1202
1203     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1204 }
1205
1206 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_GetPrivateData(ID3D10GeometryShader *iface,
1207         REFGUID guid, UINT *data_size, void *data)
1208 {
1209     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1210
1211     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1212             iface, debugstr_guid(guid), data_size, data);
1213
1214     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1215 }
1216
1217 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateData(ID3D10GeometryShader *iface,
1218         REFGUID guid, UINT data_size, const void *data)
1219 {
1220     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1221
1222     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1223             iface, debugstr_guid(guid), data_size, data);
1224
1225     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1226 }
1227
1228 static HRESULT STDMETHODCALLTYPE d3d10_geometry_shader_SetPrivateDataInterface(ID3D10GeometryShader *iface,
1229         REFGUID guid, const IUnknown *data)
1230 {
1231     struct d3d_geometry_shader *shader = impl_from_ID3D10GeometryShader(iface);
1232
1233     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1234
1235     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1236 }
1237
1238 static const struct ID3D10GeometryShaderVtbl d3d10_geometry_shader_vtbl =
1239 {
1240     /* IUnknown methods */
1241     d3d10_geometry_shader_QueryInterface,
1242     d3d10_geometry_shader_AddRef,
1243     d3d10_geometry_shader_Release,
1244     /* ID3D10DeviceChild methods */
1245     d3d10_geometry_shader_GetDevice,
1246     d3d10_geometry_shader_GetPrivateData,
1247     d3d10_geometry_shader_SetPrivateData,
1248     d3d10_geometry_shader_SetPrivateDataInterface,
1249 };
1250
1251 static void STDMETHODCALLTYPE d3d_geometry_shader_wined3d_object_destroyed(void *parent)
1252 {
1253     struct d3d_geometry_shader *shader = parent;
1254
1255     wined3d_private_store_cleanup(&shader->private_store);
1256     HeapFree(GetProcessHeap(), 0, parent);
1257 }
1258
1259 static const struct wined3d_parent_ops d3d_geometry_shader_wined3d_parent_ops =
1260 {
1261     d3d_geometry_shader_wined3d_object_destroyed,
1262 };
1263
1264 static HRESULT wined3d_so_elements_from_d3d11_so_entries(struct wined3d_stream_output_element *elements,
1265         const D3D11_SO_DECLARATION_ENTRY *entries, unsigned int entry_count,
1266         const unsigned int *buffer_strides, unsigned int buffer_stride_count,
1267         const struct wined3d_shader_signature *os, D3D_FEATURE_LEVEL feature_level)
1268 {
1269     unsigned int i, j, mask;
1270
1271     for (i = 0; i < entry_count; ++i)
1272     {
1273         struct wined3d_stream_output_element *e = &elements[i];
1274         const D3D11_SO_DECLARATION_ENTRY *f = &entries[i];
1275         struct wined3d_shader_signature_element *output;
1276
1277         TRACE("Stream: %u, semantic: %s, semantic idx: %u, start component: %u, "
1278                 "component count %u, output slot %u.\n",
1279                 f->Stream, debugstr_a(f->SemanticName), f->SemanticIndex,
1280                 f->StartComponent, f->ComponentCount, f->OutputSlot);
1281
1282         if (f->Stream >= D3D11_SO_STREAM_COUNT)
1283         {
1284             WARN("Invalid stream %u.\n", f->Stream);
1285             return E_INVALIDARG;
1286         }
1287         if (f->Stream && feature_level < D3D_FEATURE_LEVEL_11_0)
1288         {
1289             WARN("Invalid stream %u for feature level %#x.\n", f->Stream, feature_level);
1290             return E_INVALIDARG;
1291         }
1292         if (f->Stream)
1293         {
1294             FIXME("Streams not implemented yet.\n");
1295             return E_INVALIDARG;
1296         }
1297         if (f->OutputSlot >= D3D11_SO_BUFFER_SLOT_COUNT)
1298         {
1299             WARN("Invalid output slot %u.\n", f->OutputSlot);
1300             return E_INVALIDARG;
1301         }
1302
1303         e->stream_idx = f->Stream;
1304         e->component_idx = f->StartComponent;
1305         e->component_count = f->ComponentCount;
1306         e->output_slot = f->OutputSlot;
1307
1308         if (!f->SemanticName)
1309         {
1310             if (f->SemanticIndex)
1311             {
1312                 WARN("Invalid semantic idx %u for stream output gap.\n", f->SemanticIndex);
1313                 return E_INVALIDARG;
1314             }
1315             if (e->component_idx || !e->component_count)
1316             {
1317                 WARN("Invalid stream output gap %u-%u.\n", e->component_idx, e->component_count);
1318                 return E_INVALIDARG;
1319             }
1320
1321             e->register_idx = WINED3D_STREAM_OUTPUT_GAP;
1322         }
1323         else if ((output = shader_find_signature_element(os, f->SemanticName, f->SemanticIndex, f->Stream)))
1324         {
1325             if (e->component_idx > 3 || e->component_count > 4 || !e->component_count
1326                     || e->component_idx + e->component_count > 4)
1327             {
1328                 WARN("Invalid component range %u-%u.\n", e->component_idx, e->component_count);
1329                 return E_INVALIDARG;
1330             }
1331
1332             for (j = 0; j < 4; ++j)
1333             {
1334                 if ((1u << j) & output->mask)
1335                     break;
1336             }
1337             e->component_idx += j;
1338             mask = ((1u << e->component_count) - 1) << e->component_idx;
1339             if ((output->mask & 0xff & mask) != mask)
1340             {
1341                 WARN("Invalid component range %u-%u (mask %#x), output mask %#x.\n",
1342                         e->component_idx, e->component_count, mask, output->mask & 0xff);
1343                 return E_INVALIDARG;
1344             }
1345
1346             e->register_idx = output->register_idx;
1347             TRACE("Register idx: %u, register component idx %u, register mask %#x.\n",
1348                     e->register_idx, e->component_idx, mask);
1349         }
1350         else
1351         {
1352             WARN("Failed to find output signature element for stream output entry.\n");
1353             return E_INVALIDARG;
1354         }
1355     }
1356
1357     for (i = 0; i < entry_count; ++i)
1358     {
1359         const struct wined3d_stream_output_element *e1 = &elements[i];
1360         if (e1->register_idx == WINED3D_STREAM_OUTPUT_GAP)
1361             continue;
1362
1363         for (j = i + 1; j < entry_count; ++j)
1364         {
1365             const struct wined3d_stream_output_element *e2 = &elements[j];
1366
1367             if (e1->register_idx == e2->register_idx
1368                     && e1->component_idx < e2->component_idx + e2->component_count
1369                     && e1->component_idx + e1->component_count > e2->component_idx)
1370             {
1371                 WARN("Stream output elements %u and %u overlap.\n", i, j);
1372                 return E_INVALIDARG;
1373             }
1374         }
1375     }
1376
1377     for (i = 0; i < D3D11_SO_STREAM_COUNT; ++i)
1378     {
1379         unsigned int current_stride[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1380         unsigned int element_count[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1381         unsigned int gap_count[D3D11_SO_BUFFER_SLOT_COUNT] = {0};
1382
1383         for (j = 0; j < entry_count; ++j)
1384         {
1385             const struct wined3d_stream_output_element *e = &elements[j];
1386
1387             if (e->stream_idx != i)
1388                 continue;
1389             current_stride[e->output_slot] += 4 * e->component_count;
1390             ++element_count[e->output_slot];
1391             if (e->register_idx == WINED3D_STREAM_OUTPUT_GAP)
1392                 ++gap_count[e->output_slot];
1393         }
1394
1395         for (j = 0; j < D3D11_SO_BUFFER_SLOT_COUNT; ++j)
1396         {
1397             if (!element_count[j])
1398                 continue;
1399             if (element_count[j] == gap_count[j])
1400             {
1401                 WARN("Stream %u, output slot %u contains only gaps.\n", i, j);
1402                 return E_INVALIDARG;
1403             }
1404             if (buffer_stride_count)
1405             {
1406                 if (buffer_stride_count <= j)
1407                 {
1408                     WARN("Buffer strides are required for all buffer slots.\n");
1409                     return E_INVALIDARG;
1410                 }
1411                 if (buffer_strides[j] < current_stride[j] || buffer_strides[j] % 4)
1412                 {
1413                     WARN("Invalid stride %u for buffer slot %u.\n", buffer_strides[j], j);
1414                     return E_INVALIDARG;
1415                 }
1416             }
1417         }
1418
1419         if (!i && feature_level < D3D_FEATURE_LEVEL_11_0 && element_count[0] != entry_count)
1420         {
1421             for (j = 0; j < ARRAY_SIZE(element_count); ++j)
1422             {
1423                 if (element_count[j] > 1)
1424                 {
1425                     WARN("Only one element per output slot is allowed.\n");
1426                     return E_INVALIDARG;
1427                 }
1428             }
1429         }
1430     }
1431
1432     return S_OK;
1433 }
1434
1435 static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader,
1436         struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1437         const D3D11_SO_DECLARATION_ENTRY *so_entries, unsigned int so_entry_count,
1438         const unsigned int *buffer_strides, unsigned int buffer_stride_count,
1439         unsigned int rasterizer_stream)
1440 {
1441     struct wined3d_stream_output_desc so_desc;
1442     struct wined3d_shader_desc desc;
1443     unsigned int i;
1444     HRESULT hr;
1445
1446     if (so_entry_count > D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT)
1447     {
1448         WARN("Entry count %u is greater than %u.\n",
1449                 so_entry_count, D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT);
1450         return E_INVALIDARG;
1451     }
1452     if (so_entries && !so_entry_count)
1453     {
1454         WARN("Invalid SO entry count %u.\n", so_entry_count);
1455         return E_INVALIDARG;
1456     }
1457     if (rasterizer_stream != D3D11_SO_NO_RASTERIZED_STREAM && rasterizer_stream >= D3D11_SO_STREAM_COUNT)
1458     {
1459         WARN("Invalid rasterizer stream %u.\n", rasterizer_stream);
1460         return E_INVALIDARG;
1461     }
1462     if (device->feature_level < D3D_FEATURE_LEVEL_11_0)
1463     {
1464         if (rasterizer_stream)
1465         {
1466             WARN("Invalid rasterizer stream %u for feature level %#x.\n",
1467                     rasterizer_stream, device->feature_level);
1468             return E_INVALIDARG;
1469         }
1470         if (buffer_stride_count && buffer_stride_count != 1)
1471         {
1472             WARN("Invalid buffer stride count %u for feature level %#x.\n",
1473                     buffer_stride_count, device->feature_level);
1474             return E_INVALIDARG;
1475         }
1476     }
1477
1478     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
1479     {
1480         WARN("Failed to extract shader, hr %#x.\n", hr);
1481         return hr;
1482     }
1483     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1484
1485     memset(&so_desc, 0, sizeof(so_desc));
1486     if (so_entries)
1487     {
1488         so_desc.element_count = so_entry_count;
1489         for (i = 0; i < min(buffer_stride_count, ARRAY_SIZE(so_desc.buffer_strides)); ++i)
1490             so_desc.buffer_strides[i] = buffer_strides[i];
1491         so_desc.buffer_stride_count = buffer_stride_count;
1492         so_desc.rasterizer_stream_idx = rasterizer_stream;
1493
1494         if (!(so_desc.elements = d3d11_calloc(so_entry_count, sizeof(*so_desc.elements))))
1495         {
1496             ERR("Failed to allocate wined3d stream output element array memory.\n");
1497             free_shader_desc(&desc);
1498             return E_OUTOFMEMORY;
1499         }
1500         if (FAILED(hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements,
1501                 so_entries, so_entry_count, buffer_strides, buffer_stride_count,
1502                 &desc.output_signature, device->feature_level)))
1503         {
1504             HeapFree(GetProcessHeap(), 0, so_desc.elements);
1505             free_shader_desc(&desc);
1506             return hr;
1507         }
1508     }
1509
1510     shader->ID3D11GeometryShader_iface.lpVtbl = &d3d11_geometry_shader_vtbl;
1511     shader->ID3D10GeometryShader_iface.lpVtbl = &d3d10_geometry_shader_vtbl;
1512     shader->refcount = 1;
1513     wined3d_mutex_lock();
1514     wined3d_private_store_init(&shader->private_store);
1515
1516     hr = wined3d_shader_create_gs(device->wined3d_device, &desc, so_entries ? &so_desc : NULL,
1517             shader, &d3d_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader);
1518     HeapFree(GetProcessHeap(), 0, so_desc.elements);
1519     free_shader_desc(&desc);
1520     if (FAILED(hr))
1521     {
1522         WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr);
1523         wined3d_private_store_cleanup(&shader->private_store);
1524         wined3d_mutex_unlock();
1525         return E_INVALIDARG;
1526     }
1527     wined3d_mutex_unlock();
1528
1529     shader->device = &device->ID3D11Device_iface;
1530     ID3D11Device_AddRef(shader->device);
1531
1532     return S_OK;
1533 }
1534
1535 HRESULT d3d_geometry_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1536         const D3D11_SO_DECLARATION_ENTRY *so_entries, unsigned int so_entry_count,
1537         const unsigned int *buffer_strides, unsigned int buffer_stride_count, unsigned int rasterizer_stream,
1538         struct d3d_geometry_shader **shader)
1539 {
1540     struct d3d_geometry_shader *object;
1541     HRESULT hr;
1542
1543     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1544         return E_OUTOFMEMORY;
1545
1546     if (FAILED(hr = d3d_geometry_shader_init(object, device, byte_code, byte_code_length,
1547             so_entries, so_entry_count, buffer_strides, buffer_stride_count, rasterizer_stream)))
1548     {
1549         WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
1550         HeapFree(GetProcessHeap(), 0, object);
1551         return hr;
1552     }
1553
1554     TRACE("Created geometry shader %p.\n", object);
1555     *shader = object;
1556
1557     return S_OK;
1558 }
1559
1560 struct d3d_geometry_shader *unsafe_impl_from_ID3D11GeometryShader(ID3D11GeometryShader *iface)
1561 {
1562     if (!iface)
1563         return NULL;
1564     assert(iface->lpVtbl == &d3d11_geometry_shader_vtbl);
1565
1566     return impl_from_ID3D11GeometryShader(iface);
1567 }
1568
1569 struct d3d_geometry_shader *unsafe_impl_from_ID3D10GeometryShader(ID3D10GeometryShader *iface)
1570 {
1571     if (!iface)
1572         return NULL;
1573     assert(iface->lpVtbl == &d3d10_geometry_shader_vtbl);
1574
1575     return impl_from_ID3D10GeometryShader(iface);
1576 }
1577
1578 /* ID3D11PixelShader methods */
1579
1580 static inline struct d3d_pixel_shader *impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1581 {
1582     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D11PixelShader_iface);
1583 }
1584
1585 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_QueryInterface(ID3D11PixelShader *iface,
1586         REFIID riid, void **object)
1587 {
1588     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1589
1590     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1591
1592     if (IsEqualGUID(riid, &IID_ID3D11PixelShader)
1593             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1594             || IsEqualGUID(riid, &IID_IUnknown))
1595     {
1596         ID3D11PixelShader_AddRef(iface);
1597         *object = iface;
1598         return S_OK;
1599     }
1600
1601     if (IsEqualGUID(riid, &IID_ID3D10PixelShader)
1602             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1603     {
1604         IUnknown_AddRef(&shader->ID3D10PixelShader_iface);
1605         *object = &shader->ID3D10PixelShader_iface;
1606         return S_OK;
1607     }
1608
1609     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1610
1611     *object = NULL;
1612     return E_NOINTERFACE;
1613 }
1614
1615 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_AddRef(ID3D11PixelShader *iface)
1616 {
1617     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1618     ULONG refcount = InterlockedIncrement(&shader->refcount);
1619
1620     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1621
1622     if (refcount == 1)
1623     {
1624         ID3D11Device_AddRef(shader->device);
1625         wined3d_mutex_lock();
1626         wined3d_shader_incref(shader->wined3d_shader);
1627         wined3d_mutex_unlock();
1628     }
1629
1630     return refcount;
1631 }
1632
1633 static ULONG STDMETHODCALLTYPE d3d11_pixel_shader_Release(ID3D11PixelShader *iface)
1634 {
1635     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1636     ULONG refcount = InterlockedDecrement(&shader->refcount);
1637
1638     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1639
1640     if (!refcount)
1641     {
1642         ID3D11Device *device = shader->device;
1643
1644         wined3d_mutex_lock();
1645         wined3d_shader_decref(shader->wined3d_shader);
1646         wined3d_mutex_unlock();
1647         /* Release the device last, it may cause the wined3d device to be
1648          * destroyed. */
1649         ID3D11Device_Release(device);
1650     }
1651
1652     return refcount;
1653 }
1654
1655 static void STDMETHODCALLTYPE d3d11_pixel_shader_GetDevice(ID3D11PixelShader *iface,
1656         ID3D11Device **device)
1657 {
1658     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1659
1660     TRACE("iface %p, device %p.\n", iface, device);
1661
1662     *device = shader->device;
1663     ID3D11Device_AddRef(*device);
1664 }
1665
1666 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_GetPrivateData(ID3D11PixelShader *iface,
1667         REFGUID guid, UINT *data_size, void *data)
1668 {
1669     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1670
1671     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1672
1673     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1674 }
1675
1676 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateData(ID3D11PixelShader *iface,
1677         REFGUID guid, UINT data_size, const void *data)
1678 {
1679     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1680
1681     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1682
1683     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1684 }
1685
1686 static HRESULT STDMETHODCALLTYPE d3d11_pixel_shader_SetPrivateDataInterface(ID3D11PixelShader *iface,
1687         REFGUID guid, const IUnknown *data)
1688 {
1689     struct d3d_pixel_shader *shader = impl_from_ID3D11PixelShader(iface);
1690
1691     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1692
1693     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1694 }
1695
1696 static const struct ID3D11PixelShaderVtbl d3d11_pixel_shader_vtbl =
1697 {
1698     /* IUnknown methods */
1699     d3d11_pixel_shader_QueryInterface,
1700     d3d11_pixel_shader_AddRef,
1701     d3d11_pixel_shader_Release,
1702     /* ID3D11DeviceChild methods */
1703     d3d11_pixel_shader_GetDevice,
1704     d3d11_pixel_shader_GetPrivateData,
1705     d3d11_pixel_shader_SetPrivateData,
1706     d3d11_pixel_shader_SetPrivateDataInterface,
1707 };
1708
1709 /* ID3D10PixelShader methods */
1710
1711 static inline struct d3d_pixel_shader *impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1712 {
1713     return CONTAINING_RECORD(iface, struct d3d_pixel_shader, ID3D10PixelShader_iface);
1714 }
1715
1716 /* IUnknown methods */
1717
1718 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_QueryInterface(ID3D10PixelShader *iface,
1719         REFIID riid, void **object)
1720 {
1721     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1722
1723     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1724
1725     return d3d11_pixel_shader_QueryInterface(&shader->ID3D11PixelShader_iface, riid, object);
1726 }
1727
1728 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_AddRef(ID3D10PixelShader *iface)
1729 {
1730     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1731
1732     TRACE("iface %p.\n", iface);
1733
1734     return d3d11_pixel_shader_AddRef(&shader->ID3D11PixelShader_iface);
1735 }
1736
1737 static ULONG STDMETHODCALLTYPE d3d10_pixel_shader_Release(ID3D10PixelShader *iface)
1738 {
1739     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1740
1741     TRACE("iface %p.\n", iface);
1742
1743     return d3d11_pixel_shader_Release(&shader->ID3D11PixelShader_iface);
1744 }
1745
1746 /* ID3D10DeviceChild methods */
1747
1748 static void STDMETHODCALLTYPE d3d10_pixel_shader_GetDevice(ID3D10PixelShader *iface, ID3D10Device **device)
1749 {
1750     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1751
1752     TRACE("iface %p, device %p.\n", iface, device);
1753
1754     ID3D11Device_QueryInterface(shader->device, &IID_ID3D10Device, (void **)device);
1755 }
1756
1757 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_GetPrivateData(ID3D10PixelShader *iface,
1758         REFGUID guid, UINT *data_size, void *data)
1759 {
1760     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1761
1762     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1763             iface, debugstr_guid(guid), data_size, data);
1764
1765     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1766 }
1767
1768 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateData(ID3D10PixelShader *iface,
1769         REFGUID guid, UINT data_size, const void *data)
1770 {
1771     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1772
1773     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1774             iface, debugstr_guid(guid), data_size, data);
1775
1776     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1777 }
1778
1779 static HRESULT STDMETHODCALLTYPE d3d10_pixel_shader_SetPrivateDataInterface(ID3D10PixelShader *iface,
1780         REFGUID guid, const IUnknown *data)
1781 {
1782     struct d3d_pixel_shader *shader = impl_from_ID3D10PixelShader(iface);
1783
1784     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1785
1786     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1787 }
1788
1789 static const struct ID3D10PixelShaderVtbl d3d10_pixel_shader_vtbl =
1790 {
1791     /* IUnknown methods */
1792     d3d10_pixel_shader_QueryInterface,
1793     d3d10_pixel_shader_AddRef,
1794     d3d10_pixel_shader_Release,
1795     /* ID3D10DeviceChild methods */
1796     d3d10_pixel_shader_GetDevice,
1797     d3d10_pixel_shader_GetPrivateData,
1798     d3d10_pixel_shader_SetPrivateData,
1799     d3d10_pixel_shader_SetPrivateDataInterface,
1800 };
1801
1802 static void STDMETHODCALLTYPE d3d_pixel_shader_wined3d_object_destroyed(void *parent)
1803 {
1804     struct d3d_pixel_shader *shader = parent;
1805
1806     wined3d_private_store_cleanup(&shader->private_store);
1807     HeapFree(GetProcessHeap(), 0, parent);
1808 }
1809
1810 static const struct wined3d_parent_ops d3d_pixel_shader_wined3d_parent_ops =
1811 {
1812     d3d_pixel_shader_wined3d_object_destroyed,
1813 };
1814
1815 static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d_device *device,
1816         const void *byte_code, SIZE_T byte_code_length)
1817 {
1818     struct wined3d_shader_desc desc;
1819     HRESULT hr;
1820
1821     shader->ID3D11PixelShader_iface.lpVtbl = &d3d11_pixel_shader_vtbl;
1822     shader->ID3D10PixelShader_iface.lpVtbl = &d3d10_pixel_shader_vtbl;
1823     shader->refcount = 1;
1824     wined3d_mutex_lock();
1825     wined3d_private_store_init(&shader->private_store);
1826
1827     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
1828     {
1829         WARN("Failed to extract shader, hr %#x.\n", hr);
1830         wined3d_private_store_cleanup(&shader->private_store);
1831         wined3d_mutex_unlock();
1832         return hr;
1833     }
1834     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
1835
1836     hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader,
1837             &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader);
1838     free_shader_desc(&desc);
1839     if (FAILED(hr))
1840     {
1841         WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr);
1842         wined3d_private_store_cleanup(&shader->private_store);
1843         wined3d_mutex_unlock();
1844         return E_INVALIDARG;
1845     }
1846     wined3d_mutex_unlock();
1847
1848     shader->device = &device->ID3D11Device_iface;
1849     ID3D11Device_AddRef(shader->device);
1850
1851     return S_OK;
1852 }
1853
1854 HRESULT d3d_pixel_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
1855         struct d3d_pixel_shader **shader)
1856 {
1857     struct d3d_pixel_shader *object;
1858     HRESULT hr;
1859
1860     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
1861         return E_OUTOFMEMORY;
1862
1863     if (FAILED(hr = d3d_pixel_shader_init(object, device, byte_code, byte_code_length)))
1864     {
1865         WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
1866         HeapFree(GetProcessHeap(), 0, object);
1867         return hr;
1868     }
1869
1870     TRACE("Created pixel shader %p.\n", object);
1871     *shader = object;
1872
1873     return S_OK;
1874 }
1875
1876 struct d3d_pixel_shader *unsafe_impl_from_ID3D11PixelShader(ID3D11PixelShader *iface)
1877 {
1878     if (!iface)
1879         return NULL;
1880     assert(iface->lpVtbl == &d3d11_pixel_shader_vtbl);
1881
1882     return impl_from_ID3D11PixelShader(iface);
1883 }
1884
1885 struct d3d_pixel_shader *unsafe_impl_from_ID3D10PixelShader(ID3D10PixelShader *iface)
1886 {
1887     if (!iface)
1888         return NULL;
1889     assert(iface->lpVtbl == &d3d10_pixel_shader_vtbl);
1890
1891     return impl_from_ID3D10PixelShader(iface);
1892 }
1893
1894 /* ID3D11ComputeShader methods */
1895
1896 static inline struct d3d11_compute_shader *impl_from_ID3D11ComputeShader(ID3D11ComputeShader *iface)
1897 {
1898     return CONTAINING_RECORD(iface, struct d3d11_compute_shader, ID3D11ComputeShader_iface);
1899 }
1900
1901 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_QueryInterface(ID3D11ComputeShader *iface,
1902         REFIID riid, void **object)
1903 {
1904     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1905
1906     if (IsEqualGUID(riid, &IID_ID3D11ComputeShader)
1907             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1908             || IsEqualGUID(riid, &IID_IUnknown))
1909     {
1910         ID3D11ComputeShader_AddRef(*object = iface);
1911         return S_OK;
1912     }
1913
1914     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1915
1916     *object = NULL;
1917     return E_NOINTERFACE;
1918 }
1919
1920 static ULONG STDMETHODCALLTYPE d3d11_compute_shader_AddRef(ID3D11ComputeShader *iface)
1921 {
1922     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1923     ULONG refcount = InterlockedIncrement(&shader->refcount);
1924
1925     TRACE("%p increasing refcount to %u.\n", shader, refcount);
1926
1927     if (refcount == 1)
1928     {
1929         ID3D11Device_AddRef(shader->device);
1930         wined3d_mutex_lock();
1931         wined3d_shader_incref(shader->wined3d_shader);
1932         wined3d_mutex_unlock();
1933     }
1934
1935     return refcount;
1936 }
1937
1938 static ULONG STDMETHODCALLTYPE d3d11_compute_shader_Release(ID3D11ComputeShader *iface)
1939 {
1940     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1941     ULONG refcount = InterlockedDecrement(&shader->refcount);
1942
1943     TRACE("%p decreasing refcount to %u.\n", shader, refcount);
1944
1945     if (!refcount)
1946     {
1947         ID3D11Device *device = shader->device;
1948
1949         wined3d_mutex_lock();
1950         wined3d_shader_decref(shader->wined3d_shader);
1951         wined3d_mutex_unlock();
1952
1953         /* Release the device last, it may cause the wined3d device to be
1954          * destroyed. */
1955         ID3D11Device_Release(device);
1956     }
1957
1958     return refcount;
1959 }
1960
1961 static void STDMETHODCALLTYPE d3d11_compute_shader_GetDevice(ID3D11ComputeShader *iface,
1962         ID3D11Device **device)
1963 {
1964     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1965
1966     TRACE("iface %p, device %p.\n", iface, device);
1967
1968     ID3D11Device_AddRef(*device = shader->device);
1969 }
1970
1971 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_GetPrivateData(ID3D11ComputeShader *iface,
1972         REFGUID guid, UINT *data_size, void *data)
1973 {
1974     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1975
1976     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1977
1978     return d3d_get_private_data(&shader->private_store, guid, data_size, data);
1979 }
1980
1981 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_SetPrivateData(ID3D11ComputeShader *iface,
1982         REFGUID guid, UINT data_size, const void *data)
1983 {
1984     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1985
1986     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1987
1988     return d3d_set_private_data(&shader->private_store, guid, data_size, data);
1989 }
1990
1991 static HRESULT STDMETHODCALLTYPE d3d11_compute_shader_SetPrivateDataInterface(ID3D11ComputeShader *iface,
1992         REFGUID guid, const IUnknown *data)
1993 {
1994     struct d3d11_compute_shader *shader = impl_from_ID3D11ComputeShader(iface);
1995
1996     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1997
1998     return d3d_set_private_data_interface(&shader->private_store, guid, data);
1999 }
2000
2001 static const struct ID3D11ComputeShaderVtbl d3d11_compute_shader_vtbl =
2002 {
2003     /* IUnknown methods */
2004     d3d11_compute_shader_QueryInterface,
2005     d3d11_compute_shader_AddRef,
2006     d3d11_compute_shader_Release,
2007     /* ID3D11DeviceChild methods */
2008     d3d11_compute_shader_GetDevice,
2009     d3d11_compute_shader_GetPrivateData,
2010     d3d11_compute_shader_SetPrivateData,
2011     d3d11_compute_shader_SetPrivateDataInterface,
2012 };
2013
2014 static void STDMETHODCALLTYPE d3d11_compute_shader_wined3d_object_destroyed(void *parent)
2015 {
2016     struct d3d11_compute_shader *shader = parent;
2017
2018     wined3d_private_store_cleanup(&shader->private_store);
2019     HeapFree(GetProcessHeap(), 0, parent);
2020 }
2021
2022 static const struct wined3d_parent_ops d3d11_compute_shader_wined3d_parent_ops =
2023 {
2024     d3d11_compute_shader_wined3d_object_destroyed,
2025 };
2026
2027 static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, struct d3d_device *device,
2028         const void *byte_code, SIZE_T byte_code_length)
2029 {
2030     struct wined3d_shader_desc desc;
2031     HRESULT hr;
2032
2033     shader->ID3D11ComputeShader_iface.lpVtbl = &d3d11_compute_shader_vtbl;
2034     shader->refcount = 1;
2035     wined3d_mutex_lock();
2036     wined3d_private_store_init(&shader->private_store);
2037
2038     if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level)))
2039     {
2040         WARN("Failed to extract shader, hr %#x.\n", hr);
2041         wined3d_private_store_cleanup(&shader->private_store);
2042         wined3d_mutex_unlock();
2043         return hr;
2044     }
2045     desc.max_version = d3d_sm_from_feature_level(device->feature_level);
2046
2047     hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader,
2048             &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader);
2049     free_shader_desc(&desc);
2050     if (FAILED(hr))
2051     {
2052         WARN("Failed to create wined3d compute shader, hr %#x.\n", hr);
2053         wined3d_private_store_cleanup(&shader->private_store);
2054         wined3d_mutex_unlock();
2055         return E_INVALIDARG;
2056     }
2057     wined3d_mutex_unlock();
2058
2059     ID3D11Device_AddRef(shader->device = &device->ID3D11Device_iface);
2060
2061     return S_OK;
2062 }
2063
2064 HRESULT d3d11_compute_shader_create(struct d3d_device *device, const void *byte_code, SIZE_T byte_code_length,
2065         struct d3d11_compute_shader **shader)
2066 {
2067     struct d3d11_compute_shader *object;
2068     HRESULT hr;
2069
2070     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2071         return E_OUTOFMEMORY;
2072
2073     if (FAILED(hr = d3d11_compute_shader_init(object, device, byte_code, byte_code_length)))
2074     {
2075         HeapFree(GetProcessHeap(), 0, object);
2076         return hr;
2077     }
2078
2079     TRACE("Created compute shader %p.\n", object);
2080     *shader = object;
2081
2082     return S_OK;
2083 }
2084
2085 struct d3d11_compute_shader *unsafe_impl_from_ID3D11ComputeShader(ID3D11ComputeShader *iface)
2086 {
2087     if (!iface)
2088         return NULL;
2089     assert(iface->lpVtbl == &d3d11_compute_shader_vtbl);
2090
2091     return impl_from_ID3D11ComputeShader(iface);
2092 }
2093
2094 /* ID3D11ClassLinkage methods */
2095
2096 static inline struct d3d11_class_linkage *impl_from_ID3D11ClassLinkage(ID3D11ClassLinkage *iface)
2097 {
2098     return CONTAINING_RECORD(iface, struct d3d11_class_linkage, ID3D11ClassLinkage_iface);
2099 }
2100
2101 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_QueryInterface(ID3D11ClassLinkage *iface,
2102         REFIID riid, void **object)
2103 {
2104     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2105
2106     if (IsEqualGUID(riid, &IID_ID3D11ClassLinkage)
2107             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2108             || IsEqualGUID(riid, &IID_IUnknown))
2109     {
2110         ID3D11ClassLinkage_AddRef(*object = iface);
2111         return S_OK;
2112     }
2113
2114     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2115
2116     *object = NULL;
2117     return E_NOINTERFACE;
2118 }
2119
2120 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_AddRef(ID3D11ClassLinkage *iface)
2121 {
2122     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2123     ULONG refcount = InterlockedIncrement(&class_linkage->refcount);
2124
2125     TRACE("%p increasing refcount to %u.\n", class_linkage, refcount);
2126
2127     return refcount;
2128 }
2129
2130 static ULONG STDMETHODCALLTYPE d3d11_class_linkage_Release(ID3D11ClassLinkage *iface)
2131 {
2132     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2133     ULONG refcount = InterlockedDecrement(&class_linkage->refcount);
2134
2135     TRACE("%p decreasing refcount to %u.\n", class_linkage, refcount);
2136
2137     if (!refcount)
2138     {
2139         ID3D11Device *device = class_linkage->device;
2140
2141         wined3d_private_store_cleanup(&class_linkage->private_store);
2142         HeapFree(GetProcessHeap(), 0, class_linkage);
2143
2144         ID3D11Device_Release(device);
2145     }
2146
2147     return refcount;
2148 }
2149
2150 static void STDMETHODCALLTYPE d3d11_class_linkage_GetDevice(ID3D11ClassLinkage *iface,
2151         ID3D11Device **device)
2152 {
2153     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2154
2155     TRACE("iface %p, device %p.\n", iface, device);
2156
2157     ID3D11Device_AddRef(*device = class_linkage->device);
2158 }
2159
2160 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetPrivateData(ID3D11ClassLinkage *iface,
2161         REFGUID guid, UINT *data_size, void *data)
2162 {
2163     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2164
2165     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2166
2167     return d3d_get_private_data(&class_linkage->private_store, guid, data_size, data);
2168 }
2169
2170 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateData(ID3D11ClassLinkage *iface,
2171         REFGUID guid, UINT data_size, const void *data)
2172 {
2173     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2174
2175     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2176
2177     return d3d_set_private_data(&class_linkage->private_store, guid, data_size, data);
2178 }
2179
2180 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_SetPrivateDataInterface(ID3D11ClassLinkage *iface,
2181         REFGUID guid, const IUnknown *data)
2182 {
2183     struct d3d11_class_linkage *class_linkage = impl_from_ID3D11ClassLinkage(iface);
2184
2185     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2186
2187     return d3d_set_private_data_interface(&class_linkage->private_store, guid, data);
2188 }
2189
2190 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_GetClassInstance(ID3D11ClassLinkage *iface,
2191         const char *instance_name, UINT instance_index, ID3D11ClassInstance **class_instance)
2192 {
2193     FIXME("iface %p, instance_name %s, instance_index %u, class_instance %p stub!\n",
2194             iface, debugstr_a(instance_name), instance_index, class_instance);
2195
2196     return E_NOTIMPL;
2197 }
2198
2199 static HRESULT STDMETHODCALLTYPE d3d11_class_linkage_CreateClassInstance(ID3D11ClassLinkage *iface,
2200         const char *type_name, UINT cb_offset, UINT cb_vector_offset, UINT texture_offset,
2201         UINT sampler_offset, ID3D11ClassInstance **class_instance)
2202 {
2203     FIXME("iface %p, type_name %s, cb_offset %u, cb_vector_offset %u, texture_offset %u, "
2204             "sampler_offset %u, class_instance %p stub!\n",
2205             iface, debugstr_a(type_name), cb_offset, cb_vector_offset, texture_offset,
2206             sampler_offset, class_instance);
2207
2208     return E_NOTIMPL;
2209 }
2210
2211 static const struct ID3D11ClassLinkageVtbl d3d11_class_linkage_vtbl =
2212 {
2213     /* IUnknown methods */
2214     d3d11_class_linkage_QueryInterface,
2215     d3d11_class_linkage_AddRef,
2216     d3d11_class_linkage_Release,
2217     /* ID3D11DeviceChild methods */
2218     d3d11_class_linkage_GetDevice,
2219     d3d11_class_linkage_GetPrivateData,
2220     d3d11_class_linkage_SetPrivateData,
2221     d3d11_class_linkage_SetPrivateDataInterface,
2222     /* ID3D11ClassLinkage methods */
2223     d3d11_class_linkage_GetClassInstance,
2224     d3d11_class_linkage_CreateClassInstance,
2225 };
2226
2227 HRESULT d3d11_class_linkage_create(struct d3d_device *device, struct d3d11_class_linkage **class_linkage)
2228 {
2229     struct d3d11_class_linkage *object;
2230
2231     if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
2232         return E_OUTOFMEMORY;
2233
2234     object->ID3D11ClassLinkage_iface.lpVtbl = &d3d11_class_linkage_vtbl;
2235     object->refcount = 1;
2236     wined3d_private_store_init(&object->private_store);
2237
2238     ID3D11Device_AddRef(object->device = &device->ID3D11Device_iface);
2239
2240     TRACE("Created class linkage %p.\n", object);
2241     *class_linkage = object;
2242
2243     return S_OK;
2244 }