dlls/d3d11/view.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 #define NONAMELESSUNION
  21 #include "d3d11_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(d3d11);
  24
  25 static HRESULT get_resource_properties(ID3D11Resource *resource, D3D11_RESOURCE_DIMENSION *dimension,
  26         DXGI_FORMAT *format, unsigned int *miplevel_count, unsigned int *layer_count)
  27 {
  28     ID3D11Resource_GetType(resource, dimension);
  29     switch (*dimension)
  30     {
  31         case D3D11_RESOURCE_DIMENSION_BUFFER:
  32             return S_OK;
  33
  34         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
  35         {
  36             const struct d3d_texture1d *texture;
  37
  38             if (!(texture = unsafe_impl_from_ID3D11Texture1D((ID3D11Texture1D *)resource)))
  39             {
  40                 ERR("Cannot get implementation from ID3D11Texture1D.\n");
  41                 return E_FAIL;
  42             }
  43
  44             *format = texture->desc.Format;
  45             if (miplevel_count)
  46                 *miplevel_count = texture->desc.MipLevels;
  47             *layer_count = texture->desc.ArraySize;
  48             break;
  49         }
  50
  51         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
  52         {
  53             const struct d3d_texture2d *texture;
  54
  55             if (!(texture = unsafe_impl_from_ID3D11Texture2D((ID3D11Texture2D *)resource)))
  56             {
  57                 ERR("Cannot get implementation from ID3D11Texture2D.\n");
  58                 return E_FAIL;
  59             }
  60
  61             *format = texture->desc.Format;
  62             if (miplevel_count)
  63                 *miplevel_count = texture->desc.MipLevels;
  64             *layer_count = texture->desc.ArraySize;
  65             break;
  66         }
  67
  68         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
  69         {
  70             const struct d3d_texture3d *texture;
  71
  72             if (!(texture = unsafe_impl_from_ID3D11Texture3D((ID3D11Texture3D *)resource)))
  73             {
  74                 ERR("Cannot get implementation from ID3D11Texture3D.\n");
  75                 return E_FAIL;
  76             }
  77
  78             *format = texture->desc.Format;
  79             if (miplevel_count)
  80                 *miplevel_count = texture->desc.MipLevels;
  81             *layer_count = texture->desc.Depth;
  82             break;
  83         }
  84
  85         default:
  86             WARN("Invalid resource dimension %#x.\n", *dimension);
  87             return E_INVALIDARG;
  88     }
  89
  90     return S_OK;
  91 }
  92
  93 static HRESULT set_dsv_desc_from_resource(D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11Resource *resource)
  94 {
  95     D3D11_RESOURCE_DIMENSION dimension;
  96
  97     ID3D11Resource_GetType(resource, &dimension);
  98
  99     desc->Flags = 0;
 100
 101     switch (dimension)
 102     {
 103         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 104         {
 105             D3D11_TEXTURE1D_DESC texture_desc;
 106             ID3D11Texture1D *texture;
 107
 108             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
 109             {
 110                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
 111                 return E_INVALIDARG;
 112             }
 113
 114             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 115             ID3D11Texture1D_Release(texture);
 116
 117             desc->Format = texture_desc.Format;
 118             if (texture_desc.ArraySize == 1)
 119             {
 120                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1D;
 121                 desc->u.Texture1D.MipSlice = 0;
 122             }
 123             else
 124             {
 125                 desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE1DARRAY;
 126                 desc->u.Texture1DArray.MipSlice = 0;
 127                 desc->u.Texture1DArray.FirstArraySlice = 0;
 128                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 129             }
 130
 131             return S_OK;
 132         }
 133
 134         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 135         {
 136             D3D11_TEXTURE2D_DESC texture_desc;
 137             ID3D11Texture2D *texture;
 138
 139             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 140             {
 141                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 142                 return E_INVALIDARG;
 143             }
 144
 145             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 146             ID3D11Texture2D_Release(texture);
 147
 148             desc->Format = texture_desc.Format;
 149             if (texture_desc.ArraySize == 1)
 150             {
 151                 if (texture_desc.SampleDesc.Count == 1)
 152                 {
 153                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
 154                     desc->u.Texture2D.MipSlice = 0;
 155                 }
 156                 else
 157                 {
 158                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
 159                 }
 160             }
 161             else
 162             {
 163                 if (texture_desc.SampleDesc.Count == 1)
 164                 {
 165                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
 166                     desc->u.Texture2DArray.MipSlice = 0;
 167                     desc->u.Texture2DArray.FirstArraySlice = 0;
 168                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 169                 }
 170                 else
 171                 {
 172                     desc->ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
 173                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 174                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 175                 }
 176             }
 177
 178             return S_OK;
 179         }
 180
 181         case D3D11_RESOURCE_DIMENSION_BUFFER:
 182         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 183         default:
 184             WARN("Invalid resource dimension %#x.\n", dimension);
 185             return E_INVALIDARG;
 186     }
 187 }
 188
 189 static HRESULT normalize_dsv_desc(D3D11_DEPTH_STENCIL_VIEW_DESC *desc, ID3D11Resource *resource)
 190 {
 191     D3D11_RESOURCE_DIMENSION dimension;
 192     unsigned int layer_count;
 193     DXGI_FORMAT format;
 194     HRESULT hr;
 195
 196     if (FAILED(hr = get_resource_properties(resource, &dimension, &format, NULL, &layer_count)))
 197         return hr;
 198     switch (dimension)
 199     {
 200         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 201             if (desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE1D
 202                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE1DARRAY)
 203             {
 204                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 205                 return E_INVALIDARG;
 206             }
 207             break;
 208
 209         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 210             if (desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2D
 211                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DARRAY
 212                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DMS
 213                     && desc->ViewDimension != D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY)
 214             {
 215                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 216                 return E_INVALIDARG;
 217             }
 218             break;
 219
 220         case D3D11_RESOURCE_DIMENSION_BUFFER:
 221         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 222         default:
 223             WARN("Invalid resource dimension %#x.\n", dimension);
 224             return E_INVALIDARG;
 225     }
 226
 227     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 228         desc->Format = format;
 229
 230     switch (desc->ViewDimension)
 231     {
 232         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
 233             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 234                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 235             break;
 236
 237         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
 238             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 239                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 240             break;
 241
 242         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
 243             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 244                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 245             break;
 246
 247         default:
 248             break;
 249     }
 250
 251     return S_OK;
 252 }
 253
 254 static HRESULT set_rtv_desc_from_resource(D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11Resource *resource)
 255 {
 256     D3D11_RESOURCE_DIMENSION dimension;
 257     HRESULT hr;
 258
 259     ID3D11Resource_GetType(resource, &dimension);
 260
 261     switch (dimension)
 262     {
 263         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 264         {
 265             ID3D11Texture1D *texture;
 266             D3D11_TEXTURE1D_DESC texture_desc;
 267
 268             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture);
 269             if (FAILED(hr))
 270             {
 271                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D?\n");
 272                 return E_INVALIDARG;
 273             }
 274
 275             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 276             ID3D11Texture1D_Release(texture);
 277
 278             desc->Format = texture_desc.Format;
 279             if (texture_desc.ArraySize == 1)
 280             {
 281                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1D;
 282                 desc->u.Texture1D.MipSlice = 0;
 283             }
 284             else
 285             {
 286                 desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE1DARRAY;
 287                 desc->u.Texture1DArray.MipSlice = 0;
 288                 desc->u.Texture1DArray.FirstArraySlice = 0;
 289                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 290             }
 291
 292             return S_OK;
 293         }
 294
 295         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 296         {
 297             ID3D11Texture2D *texture;
 298             D3D11_TEXTURE2D_DESC texture_desc;
 299
 300             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture);
 301             if (FAILED(hr))
 302             {
 303                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D?\n");
 304                 return E_INVALIDARG;
 305             }
 306
 307             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 308             ID3D11Texture2D_Release(texture);
 309
 310             desc->Format = texture_desc.Format;
 311             if (texture_desc.ArraySize == 1)
 312             {
 313                 if (texture_desc.SampleDesc.Count == 1)
 314                 {
 315                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
 316                     desc->u.Texture2D.MipSlice = 0;
 317                 }
 318                 else
 319                 {
 320                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
 321                 }
 322             }
 323             else
 324             {
 325                 if (texture_desc.SampleDesc.Count == 1)
 326                 {
 327                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
 328                     desc->u.Texture2DArray.MipSlice = 0;
 329                     desc->u.Texture2DArray.FirstArraySlice = 0;
 330                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 331                 }
 332                 else
 333                 {
 334                     desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY;
 335                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 336                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 337                 }
 338             }
 339
 340             return S_OK;
 341         }
 342
 343         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 344         {
 345             ID3D11Texture3D *texture;
 346             D3D11_TEXTURE3D_DESC texture_desc;
 347
 348             hr = ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture);
 349             if (FAILED(hr))
 350             {
 351                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D?\n");
 352                 return E_INVALIDARG;
 353             }
 354
 355             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 356             ID3D11Texture3D_Release(texture);
 357
 358             desc->Format = texture_desc.Format;
 359             desc->ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;
 360             desc->u.Texture3D.MipSlice = 0;
 361             desc->u.Texture3D.FirstWSlice = 0;
 362             desc->u.Texture3D.WSize = texture_desc.Depth;
 363
 364             return S_OK;
 365         }
 366
 367         default:
 368             FIXME("Unhandled resource dimension %#x.\n", dimension);
 369             return E_INVALIDARG;
 370     }
 371 }
 372
 373 static HRESULT normalize_rtv_desc(D3D11_RENDER_TARGET_VIEW_DESC *desc, ID3D11Resource *resource)
 374 {
 375     D3D11_RESOURCE_DIMENSION dimension;
 376     unsigned int layer_count;
 377     DXGI_FORMAT format;
 378     HRESULT hr;
 379
 380     if (FAILED(hr = get_resource_properties(resource, &dimension, &format, NULL, &layer_count)))
 381         return hr;
 382     switch (dimension)
 383     {
 384         case D3D11_RESOURCE_DIMENSION_BUFFER:
 385             if (desc->ViewDimension != D3D11_RTV_DIMENSION_BUFFER)
 386             {
 387                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 388                 return E_INVALIDARG;
 389             }
 390             return S_OK;
 391
 392         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 393             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE1D
 394                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE1DARRAY)
 395             {
 396                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 397                 return E_INVALIDARG;
 398             }
 399             break;
 400
 401         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 402             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2D
 403                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DARRAY
 404                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DMS
 405                     && desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY)
 406             {
 407                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 408                 return E_INVALIDARG;
 409             }
 410             break;
 411
 412         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 413             if (desc->ViewDimension != D3D11_RTV_DIMENSION_TEXTURE3D)
 414             {
 415                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 416                 return E_INVALIDARG;
 417             }
 418             break;
 419
 420         default:
 421             WARN("Invalid resource dimension %#x.\n", dimension);
 422             return E_INVALIDARG;
 423     }
 424
 425     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 426         desc->Format = format;
 427
 428     switch (desc->ViewDimension)
 429     {
 430         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
 431             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 432                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 433             break;
 434
 435         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
 436             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 437                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 438             break;
 439
 440         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
 441             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 442                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 443             break;
 444
 445         case D3D11_RTV_DIMENSION_TEXTURE3D:
 446             layer_count = max(1, layer_count >> desc->u.Texture3D.MipSlice);
 447             if (desc->u.Texture3D.WSize == ~0u && desc->u.Texture3D.FirstWSlice < layer_count)
 448                 desc->u.Texture3D.WSize = layer_count - desc->u.Texture3D.FirstWSlice;
 449             break;
 450
 451         default:
 452             break;
 453     }
 454
 455     return S_OK;
 456 }
 457
 458 static HRESULT set_srv_desc_from_resource(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 459 {
 460     D3D11_RESOURCE_DIMENSION dimension;
 461
 462     ID3D11Resource_GetType(resource, &dimension);
 463
 464     switch (dimension)
 465     {
 466         case D3D11_RESOURCE_DIMENSION_BUFFER:
 467         {
 468             D3D11_BUFFER_DESC buffer_desc;
 469             ID3D11Buffer *buffer;
 470
 471             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Buffer, (void **)&buffer)))
 472             {
 473                 ERR("Resource of type BUFFER doesn't implement ID3D11Buffer.\n");
 474                 return E_INVALIDARG;
 475             }
 476
 477             ID3D11Buffer_GetDesc(buffer, &buffer_desc);
 478             ID3D11Buffer_Release(buffer);
 479
 480             if (buffer_desc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 481             {
 482                 desc->Format = DXGI_FORMAT_UNKNOWN;
 483                 desc->ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
 484                 desc->u.Buffer.u1.FirstElement = 0;
 485                 desc->u.Buffer.u2.NumElements = buffer_desc.ByteWidth / buffer_desc.StructureByteStride;
 486                 return S_OK;
 487             }
 488
 489             return E_INVALIDARG;
 490         }
 491
 492         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 493         {
 494             D3D11_TEXTURE1D_DESC texture_desc;
 495             ID3D11Texture1D *texture;
 496
 497             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture1D, (void **)&texture)))
 498             {
 499                 ERR("Resource of type TEXTURE1D doesn't implement ID3D11Texture1D.\n");
 500                 return E_INVALIDARG;
 501             }
 502
 503             ID3D11Texture1D_GetDesc(texture, &texture_desc);
 504             ID3D11Texture1D_Release(texture);
 505
 506             desc->Format = texture_desc.Format;
 507             if (texture_desc.ArraySize == 1)
 508             {
 509                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
 510                 desc->u.Texture1D.MostDetailedMip = 0;
 511                 desc->u.Texture1D.MipLevels = texture_desc.MipLevels;
 512             }
 513             else
 514             {
 515                 desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
 516                 desc->u.Texture1DArray.MostDetailedMip = 0;
 517                 desc->u.Texture1DArray.MipLevels = texture_desc.MipLevels;
 518                 desc->u.Texture1DArray.FirstArraySlice = 0;
 519                 desc->u.Texture1DArray.ArraySize = texture_desc.ArraySize;
 520             }
 521
 522             return S_OK;
 523         }
 524
 525         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 526         {
 527             D3D11_TEXTURE2D_DESC texture_desc;
 528             ID3D11Texture2D *texture;
 529
 530             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 531             {
 532                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 533                 return E_INVALIDARG;
 534             }
 535
 536             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 537             ID3D11Texture2D_Release(texture);
 538
 539             desc->Format = texture_desc.Format;
 540             if (texture_desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE)
 541             {
 542                 if (texture_desc.ArraySize >= 12)
 543                 {
 544                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
 545                     desc->u.TextureCubeArray.MostDetailedMip = 0;
 546                     desc->u.TextureCubeArray.MipLevels = texture_desc.MipLevels;
 547                     desc->u.TextureCubeArray.First2DArrayFace = 0;
 548                     desc->u.TextureCubeArray.NumCubes = texture_desc.ArraySize / 6;
 549                 }
 550                 else
 551                 {
 552                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
 553                     desc->u.TextureCube.MostDetailedMip = 0;
 554                     desc->u.TextureCube.MipLevels = texture_desc.MipLevels;
 555                 }
 556             }
 557             else if (texture_desc.ArraySize == 1)
 558             {
 559                 if (texture_desc.SampleDesc.Count == 1)
 560                 {
 561                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
 562                     desc->u.Texture2D.MostDetailedMip = 0;
 563                     desc->u.Texture2D.MipLevels = texture_desc.MipLevels;
 564                 }
 565                 else
 566                 {
 567                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 568                 }
 569             }
 570             else
 571             {
 572                 if (texture_desc.SampleDesc.Count == 1)
 573                 {
 574                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
 575                     desc->u.Texture2DArray.MostDetailedMip = 0;
 576                     desc->u.Texture2DArray.MipLevels = texture_desc.MipLevels;
 577                     desc->u.Texture2DArray.FirstArraySlice = 0;
 578                     desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 579                 }
 580                 else
 581                 {
 582                     desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY;
 583                     desc->u.Texture2DMSArray.FirstArraySlice = 0;
 584                     desc->u.Texture2DMSArray.ArraySize = texture_desc.ArraySize;
 585                 }
 586             }
 587
 588             return S_OK;
 589         }
 590
 591         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 592         {
 593             D3D11_TEXTURE3D_DESC texture_desc;
 594             ID3D11Texture3D *texture;
 595
 596             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 597             {
 598                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 599                 return E_INVALIDARG;
 600             }
 601
 602             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 603             ID3D11Texture3D_Release(texture);
 604
 605             desc->Format = texture_desc.Format;
 606             desc->ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
 607             desc->u.Texture3D.MostDetailedMip = 0;
 608             desc->u.Texture3D.MipLevels = texture_desc.MipLevels;
 609
 610             return S_OK;
 611         }
 612
 613         default:
 614             WARN("Invalid resource dimension %#x.\n", dimension);
 615             return E_INVALIDARG;
 616     }
 617 }
 618
 619 static HRESULT normalize_srv_desc(D3D11_SHADER_RESOURCE_VIEW_DESC *desc, ID3D11Resource *resource)
 620 {
 621     unsigned int miplevel_count, layer_count;
 622     D3D11_RESOURCE_DIMENSION dimension;
 623     DXGI_FORMAT format;
 624     HRESULT hr;
 625
 626     if (FAILED(hr = get_resource_properties(resource, &dimension, &format, &miplevel_count, &layer_count)))
 627         return hr;
 628     switch (dimension)
 629     {
 630         case D3D11_RESOURCE_DIMENSION_BUFFER:
 631             if (desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFER
 632                     && desc->ViewDimension != D3D11_SRV_DIMENSION_BUFFEREX)
 633             {
 634                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 635                 return E_INVALIDARG;
 636             }
 637             if (!desc->u.Buffer.u2.NumElements)
 638             {
 639                 WARN("Zero sized buffer view.\n");
 640                 return E_INVALIDARG;
 641             }
 642             return S_OK;
 643
 644         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 645             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1D
 646                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE1DARRAY)
 647             {
 648                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 649                 return E_INVALIDARG;
 650             }
 651             break;
 652
 653         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 654             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2D
 655                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DARRAY
 656                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMS
 657                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY
 658                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBE
 659                     && desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURECUBEARRAY)
 660             {
 661                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 662                 return E_INVALIDARG;
 663             }
 664             break;
 665
 666         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 667             if (desc->ViewDimension != D3D11_SRV_DIMENSION_TEXTURE3D)
 668             {
 669                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 670                 return E_INVALIDARG;
 671             }
 672             break;
 673
 674         default:
 675             WARN("Invalid resource dimension %#x.\n", dimension);
 676             return E_INVALIDARG;
 677     }
 678
 679     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 680         desc->Format = format;
 681
 682     switch (desc->ViewDimension)
 683     {
 684         case D3D11_SRV_DIMENSION_TEXTURE1D:
 685             if (desc->u.Texture1D.MipLevels == ~0u && desc->u.Texture1D.MostDetailedMip < miplevel_count)
 686                 desc->u.Texture1D.MipLevels = miplevel_count - desc->u.Texture1D.MostDetailedMip;
 687             break;
 688
 689         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
 690             if (desc->u.Texture1DArray.MipLevels == ~0u && desc->u.Texture1DArray.MostDetailedMip < miplevel_count)
 691                 desc->u.Texture1DArray.MipLevels = miplevel_count - desc->u.Texture1DArray.MostDetailedMip;
 692             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < miplevel_count)
 693                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 694             break;
 695
 696         case D3D11_SRV_DIMENSION_TEXTURE2D:
 697             if (desc->u.Texture2D.MipLevels == ~0u && desc->u.Texture2D.MostDetailedMip < miplevel_count)
 698                 desc->u.Texture2D.MipLevels = miplevel_count - desc->u.Texture2D.MostDetailedMip;
 699             break;
 700
 701         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
 702             if (desc->u.Texture2DArray.MipLevels == ~0u && desc->u.Texture2DArray.MostDetailedMip < miplevel_count)
 703                 desc->u.Texture2DArray.MipLevels = miplevel_count - desc->u.Texture2DArray.MostDetailedMip;
 704             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 705                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 706             break;
 707
 708         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
 709             if (desc->u.Texture2DMSArray.ArraySize == ~0u && desc->u.Texture2DMSArray.FirstArraySlice < layer_count)
 710                 desc->u.Texture2DMSArray.ArraySize = layer_count - desc->u.Texture2DMSArray.FirstArraySlice;
 711             break;
 712
 713         case D3D11_SRV_DIMENSION_TEXTURE3D:
 714             if (desc->u.Texture3D.MipLevels == ~0u && desc->u.Texture3D.MostDetailedMip < miplevel_count)
 715                 desc->u.Texture3D.MipLevels = miplevel_count - desc->u.Texture3D.MostDetailedMip;
 716             break;
 717
 718         case D3D11_SRV_DIMENSION_TEXTURECUBE:
 719             if (desc->u.TextureCube.MipLevels == ~0u && desc->u.TextureCube.MostDetailedMip < miplevel_count)
 720                 desc->u.TextureCube.MipLevels = miplevel_count - desc->u.TextureCube.MostDetailedMip;
 721             break;
 722
 723         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
 724             if (desc->u.TextureCubeArray.MipLevels == ~0u && desc->u.TextureCubeArray.MostDetailedMip < miplevel_count)
 725                 desc->u.TextureCubeArray.MipLevels = miplevel_count - desc->u.TextureCubeArray.MostDetailedMip;
 726             if (desc->u.TextureCubeArray.NumCubes == ~0u && desc->u.TextureCubeArray.First2DArrayFace < layer_count)
 727                 desc->u.TextureCubeArray.NumCubes = (layer_count - desc->u.TextureCubeArray.First2DArrayFace) / 6;
 728             break;
 729
 730         default:
 731             break;
 732     }
 733
 734     return S_OK;
 735 }
 736
 737 static HRESULT set_uav_desc_from_resource(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 738 {
 739     D3D11_RESOURCE_DIMENSION dimension;
 740
 741     ID3D11Resource_GetType(resource, &dimension);
 742
 743     switch (dimension)
 744     {
 745         case D3D11_RESOURCE_DIMENSION_BUFFER:
 746         {
 747             D3D11_BUFFER_DESC buffer_desc;
 748             ID3D11Buffer *buffer;
 749
 750             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Buffer, (void **)&buffer)))
 751             {
 752                 ERR("Resource of type BUFFER doesn't implement ID3D11Buffer.\n");
 753                 return E_INVALIDARG;
 754             }
 755
 756             ID3D11Buffer_GetDesc(buffer, &buffer_desc);
 757             ID3D11Buffer_Release(buffer);
 758
 759             if (buffer_desc.MiscFlags & D3D11_RESOURCE_MISC_BUFFER_STRUCTURED)
 760             {
 761                 desc->Format = DXGI_FORMAT_UNKNOWN;
 762                 desc->ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
 763                 desc->u.Buffer.FirstElement = 0;
 764                 desc->u.Buffer.NumElements = buffer_desc.ByteWidth / buffer_desc.StructureByteStride;
 765                 desc->u.Buffer.Flags = 0;
 766                 return S_OK;
 767             }
 768
 769             return E_INVALIDARG;
 770         }
 771
 772         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 773         {
 774             D3D11_TEXTURE2D_DESC texture_desc;
 775             ID3D11Texture2D *texture;
 776
 777             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture2D, (void **)&texture)))
 778             {
 779                 ERR("Resource of type TEXTURE2D doesn't implement ID3D11Texture2D.\n");
 780                 return E_INVALIDARG;
 781             }
 782
 783             ID3D11Texture2D_GetDesc(texture, &texture_desc);
 784             ID3D11Texture2D_Release(texture);
 785
 786             if (texture_desc.SampleDesc.Count != 1)
 787             {
 788                 WARN("Trying to create view for multisample texture.\n");
 789                 return E_INVALIDARG;
 790             }
 791
 792             desc->Format = texture_desc.Format;
 793             if (texture_desc.ArraySize == 1)
 794             {
 795                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
 796                 desc->u.Texture2D.MipSlice = 0;
 797             }
 798             else
 799             {
 800                 desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
 801                 desc->u.Texture2DArray.MipSlice = 0;
 802                 desc->u.Texture2DArray.FirstArraySlice = 0;
 803                 desc->u.Texture2DArray.ArraySize = texture_desc.ArraySize;
 804             }
 805
 806             return S_OK;
 807         }
 808
 809         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 810         {
 811             D3D11_TEXTURE3D_DESC texture_desc;
 812             ID3D11Texture3D *texture;
 813
 814             if (FAILED(ID3D11Resource_QueryInterface(resource, &IID_ID3D11Texture3D, (void **)&texture)))
 815             {
 816                 ERR("Resource of type TEXTURE3D doesn't implement ID3D11Texture3D.\n");
 817                 return E_INVALIDARG;
 818             }
 819
 820             ID3D11Texture3D_GetDesc(texture, &texture_desc);
 821             ID3D11Texture3D_Release(texture);
 822
 823             desc->Format = texture_desc.Format;
 824             desc->ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;
 825             desc->u.Texture3D.MipSlice = 0;
 826             desc->u.Texture3D.FirstWSlice = 0;
 827             desc->u.Texture3D.WSize = texture_desc.Depth;
 828
 829             return S_OK;
 830         }
 831
 832         default:
 833             FIXME("Unhandled resource dimension %#x.\n", dimension);
 834             return E_INVALIDARG;
 835     }
 836 }
 837
 838 static HRESULT normalize_uav_desc(D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, ID3D11Resource *resource)
 839 {
 840     D3D11_RESOURCE_DIMENSION dimension;
 841     unsigned int layer_count;
 842     DXGI_FORMAT format;
 843     HRESULT hr;
 844
 845     if (FAILED(hr = get_resource_properties(resource, &dimension, &format, NULL, &layer_count)))
 846         return hr;
 847     switch (dimension)
 848     {
 849         case D3D11_RESOURCE_DIMENSION_BUFFER:
 850             if (desc->ViewDimension != D3D11_UAV_DIMENSION_BUFFER)
 851             {
 852                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 853                 return E_INVALIDARG;
 854             }
 855             return S_OK;
 856
 857         case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
 858             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1D
 859                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE1DARRAY)
 860             {
 861                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 862                 return E_INVALIDARG;
 863             }
 864             break;
 865
 866         case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
 867             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2D
 868                     && desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE2DARRAY)
 869             {
 870                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 871                 return E_INVALIDARG;
 872             }
 873             break;
 874
 875         case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
 876             if (desc->ViewDimension != D3D11_UAV_DIMENSION_TEXTURE3D)
 877             {
 878                 WARN("Incompatible dimensions %#x, %#x.\n", dimension, desc->ViewDimension);
 879                 return E_INVALIDARG;
 880             }
 881             break;
 882
 883         default:
 884             WARN("Invalid resource dimension %#x.\n", dimension);
 885             return E_INVALIDARG;
 886     }
 887
 888     if (desc->Format == DXGI_FORMAT_UNKNOWN)
 889         desc->Format = format;
 890
 891     switch (desc->ViewDimension)
 892     {
 893         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
 894             if (desc->u.Texture1DArray.ArraySize == ~0u && desc->u.Texture1DArray.FirstArraySlice < layer_count)
 895                 desc->u.Texture1DArray.ArraySize = layer_count - desc->u.Texture1DArray.FirstArraySlice;
 896             break;
 897
 898         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
 899             if (desc->u.Texture2DArray.ArraySize == ~0u && desc->u.Texture2DArray.FirstArraySlice < layer_count)
 900                 desc->u.Texture2DArray.ArraySize = layer_count - desc->u.Texture2DArray.FirstArraySlice;
 901             break;
 902
 903         case D3D11_UAV_DIMENSION_TEXTURE3D:
 904             layer_count = max(1, layer_count >> desc->u.Texture3D.MipSlice);
 905             if (desc->u.Texture3D.WSize == ~0u && desc->u.Texture3D.FirstWSlice < layer_count)
 906                 desc->u.Texture3D.WSize = layer_count - desc->u.Texture3D.FirstWSlice;
 907             break;
 908
 909         default:
 910             break;
 911     }
 912
 913     return S_OK;
 914 }
 915
 916 /* ID3D11DepthStencilView methods */
 917
 918 static inline struct d3d_depthstencil_view *impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
 919 {
 920     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D11DepthStencilView_iface);
 921 }
 922
 923 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_QueryInterface(ID3D11DepthStencilView *iface,
 924         REFIID riid, void **object)
 925 {
 926     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 927
 928     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
 929
 930     if (IsEqualGUID(riid, &IID_ID3D11DepthStencilView)
 931             || IsEqualGUID(riid, &IID_ID3D11View)
 932             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
 933             || IsEqualGUID(riid, &IID_IUnknown))
 934     {
 935         ID3D11DepthStencilView_AddRef(iface);
 936         *object = iface;
 937         return S_OK;
 938     }
 939
 940     if (IsEqualGUID(riid, &IID_ID3D10DepthStencilView)
 941             || IsEqualGUID(riid, &IID_ID3D10View)
 942             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
 943     {
 944         ID3D10DepthStencilView_AddRef(&view->ID3D10DepthStencilView_iface);
 945         *object = &view->ID3D10DepthStencilView_iface;
 946         return S_OK;
 947     }
 948
 949     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
 950
 951     *object = NULL;
 952     return E_NOINTERFACE;
 953 }
 954
 955 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_AddRef(ID3D11DepthStencilView *iface)
 956 {
 957     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 958     ULONG refcount = InterlockedIncrement(&view->refcount);
 959
 960     TRACE("%p increasing refcount to %u.\n", view, refcount);
 961
 962     if (refcount == 1)
 963     {
 964         ID3D11Device2_AddRef(view->device);
 965         wined3d_mutex_lock();
 966         wined3d_rendertarget_view_incref(view->wined3d_view);
 967         wined3d_mutex_unlock();
 968     }
 969
 970     return refcount;
 971 }
 972
 973 static ULONG STDMETHODCALLTYPE d3d11_depthstencil_view_Release(ID3D11DepthStencilView *iface)
 974 {
 975     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 976     ULONG refcount = InterlockedDecrement(&view->refcount);
 977
 978     TRACE("%p decreasing refcount to %u.\n", view, refcount);
 979
 980     if (!refcount)
 981     {
 982         ID3D11Device2 *device = view->device;
 983
 984         wined3d_mutex_lock();
 985         wined3d_rendertarget_view_decref(view->wined3d_view);
 986         wined3d_mutex_unlock();
 987
 988         ID3D11Device2_Release(device);
 989     }
 990
 991     return refcount;
 992 }
 993
 994 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDevice(ID3D11DepthStencilView *iface,
 995         ID3D11Device **device)
 996 {
 997     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
 998
 999     TRACE("iface %p, device %p.\n", iface, device);
1000
1001     *device = (ID3D11Device *)view->device;
1002     ID3D11Device_AddRef(*device);
1003 }
1004
1005 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_GetPrivateData(ID3D11DepthStencilView *iface,
1006         REFGUID guid, UINT *data_size, void *data)
1007 {
1008     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1009
1010     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1011
1012     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1013 }
1014
1015 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateData(ID3D11DepthStencilView *iface,
1016         REFGUID guid, UINT data_size, const void *data)
1017 {
1018     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1019
1020     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1021
1022     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1023 }
1024
1025 static HRESULT STDMETHODCALLTYPE d3d11_depthstencil_view_SetPrivateDataInterface(ID3D11DepthStencilView *iface,
1026         REFGUID guid, const IUnknown *data)
1027 {
1028     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1029
1030     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1031
1032     return d3d_set_private_data_interface(&view->private_store, guid, data);
1033 }
1034
1035 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetResource(ID3D11DepthStencilView *iface,
1036         ID3D11Resource **resource)
1037 {
1038     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1039
1040     TRACE("iface %p, resource %p.\n", iface, resource);
1041
1042     *resource = view->resource;
1043     ID3D11Resource_AddRef(*resource);
1044 }
1045
1046 static void STDMETHODCALLTYPE d3d11_depthstencil_view_GetDesc(ID3D11DepthStencilView *iface,
1047         D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1048 {
1049     struct d3d_depthstencil_view *view = impl_from_ID3D11DepthStencilView(iface);
1050
1051     TRACE("iface %p, desc %p.\n", iface, desc);
1052
1053     *desc = view->desc;
1054 }
1055
1056 static const struct ID3D11DepthStencilViewVtbl d3d11_depthstencil_view_vtbl =
1057 {
1058     /* IUnknown methods */
1059     d3d11_depthstencil_view_QueryInterface,
1060     d3d11_depthstencil_view_AddRef,
1061     d3d11_depthstencil_view_Release,
1062     /* ID3D11DeviceChild methods */
1063     d3d11_depthstencil_view_GetDevice,
1064     d3d11_depthstencil_view_GetPrivateData,
1065     d3d11_depthstencil_view_SetPrivateData,
1066     d3d11_depthstencil_view_SetPrivateDataInterface,
1067     /* ID3D11View methods */
1068     d3d11_depthstencil_view_GetResource,
1069     /* ID3D11DepthStencilView methods */
1070     d3d11_depthstencil_view_GetDesc,
1071 };
1072
1073 /* ID3D10DepthStencilView methods */
1074
1075 static inline struct d3d_depthstencil_view *impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1076 {
1077     return CONTAINING_RECORD(iface, struct d3d_depthstencil_view, ID3D10DepthStencilView_iface);
1078 }
1079
1080 /* IUnknown methods */
1081
1082 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_QueryInterface(ID3D10DepthStencilView *iface,
1083         REFIID riid, void **object)
1084 {
1085     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1086
1087     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1088
1089     return d3d11_depthstencil_view_QueryInterface(&view->ID3D11DepthStencilView_iface, riid, object);
1090 }
1091
1092 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_AddRef(ID3D10DepthStencilView *iface)
1093 {
1094     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1095
1096     TRACE("iface %p.\n", iface);
1097
1098     return d3d11_depthstencil_view_AddRef(&view->ID3D11DepthStencilView_iface);
1099 }
1100
1101 static ULONG STDMETHODCALLTYPE d3d10_depthstencil_view_Release(ID3D10DepthStencilView *iface)
1102 {
1103     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1104
1105     TRACE("iface %p.\n", iface);
1106
1107     return d3d11_depthstencil_view_Release(&view->ID3D11DepthStencilView_iface);
1108 }
1109
1110 /* ID3D10DeviceChild methods */
1111
1112 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDevice(ID3D10DepthStencilView *iface, ID3D10Device **device)
1113 {
1114     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1115
1116     TRACE("iface %p, device %p.\n", iface, device);
1117
1118     ID3D11Device2_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1119 }
1120
1121 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_GetPrivateData(ID3D10DepthStencilView *iface,
1122         REFGUID guid, UINT *data_size, void *data)
1123 {
1124     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1125
1126     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1127             iface, debugstr_guid(guid), data_size, data);
1128
1129     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1130 }
1131
1132 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateData(ID3D10DepthStencilView *iface,
1133         REFGUID guid, UINT data_size, const void *data)
1134 {
1135     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1136
1137     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1138             iface, debugstr_guid(guid), data_size, data);
1139
1140     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1141 }
1142
1143 static HRESULT STDMETHODCALLTYPE d3d10_depthstencil_view_SetPrivateDataInterface(ID3D10DepthStencilView *iface,
1144         REFGUID guid, const IUnknown *data)
1145 {
1146     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1147
1148     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1149
1150     return d3d_set_private_data_interface(&view->private_store, guid, data);
1151 }
1152
1153 /* ID3D10View methods */
1154
1155 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetResource(ID3D10DepthStencilView *iface,
1156         ID3D10Resource **resource)
1157 {
1158     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1159
1160     TRACE("iface %p, resource %p.\n", iface, resource);
1161
1162     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1163 }
1164
1165 /* ID3D10DepthStencilView methods */
1166
1167 static void STDMETHODCALLTYPE d3d10_depthstencil_view_GetDesc(ID3D10DepthStencilView *iface,
1168         D3D10_DEPTH_STENCIL_VIEW_DESC *desc)
1169 {
1170     struct d3d_depthstencil_view *view = impl_from_ID3D10DepthStencilView(iface);
1171     const D3D11_DEPTH_STENCIL_VIEW_DESC *d3d11_desc = &view->desc;
1172
1173     TRACE("iface %p, desc %p.\n", iface, desc);
1174
1175     desc->Format = d3d11_desc->Format;
1176     desc->ViewDimension = (D3D10_DSV_DIMENSION)d3d11_desc->ViewDimension;
1177     memcpy(&desc->u, &d3d11_desc->u, sizeof(desc->u));
1178 }
1179
1180 static const struct ID3D10DepthStencilViewVtbl d3d10_depthstencil_view_vtbl =
1181 {
1182     /* IUnknown methods */
1183     d3d10_depthstencil_view_QueryInterface,
1184     d3d10_depthstencil_view_AddRef,
1185     d3d10_depthstencil_view_Release,
1186     /* ID3D10DeviceChild methods */
1187     d3d10_depthstencil_view_GetDevice,
1188     d3d10_depthstencil_view_GetPrivateData,
1189     d3d10_depthstencil_view_SetPrivateData,
1190     d3d10_depthstencil_view_SetPrivateDataInterface,
1191     /* ID3D10View methods */
1192     d3d10_depthstencil_view_GetResource,
1193     /* ID3D10DepthStencilView methods */
1194     d3d10_depthstencil_view_GetDesc,
1195 };
1196
1197 static void STDMETHODCALLTYPE d3d_depth_stencil_view_wined3d_object_destroyed(void *parent)
1198 {
1199     struct d3d_depthstencil_view *view = parent;
1200
1201     wined3d_private_store_cleanup(&view->private_store);
1202     heap_free(parent);
1203 }
1204
1205 static const struct wined3d_parent_ops d3d_depth_stencil_view_wined3d_parent_ops =
1206 {
1207     d3d_depth_stencil_view_wined3d_object_destroyed,
1208 };
1209
1210 static void wined3d_depth_stencil_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
1211         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1212 {
1213     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1214
1215     wined3d_desc->flags = 0;
1216     if (desc->Flags & D3D11_DSV_READ_ONLY_DEPTH)
1217         wined3d_desc->flags |= WINED3D_VIEW_READ_ONLY_DEPTH;
1218     if (desc->Flags & D3D11_DSV_READ_ONLY_STENCIL)
1219         wined3d_desc->flags |= WINED3D_VIEW_READ_ONLY_STENCIL;
1220
1221     wined3d_desc->u.texture.level_count = 1;
1222     switch (desc->ViewDimension)
1223     {
1224         case D3D11_DSV_DIMENSION_TEXTURE1D:
1225             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1226             wined3d_desc->u.texture.layer_idx = 0;
1227             wined3d_desc->u.texture.layer_count = 1;
1228             break;
1229
1230         case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:
1231             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1232             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1233             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1234             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1235             break;
1236
1237         case D3D11_DSV_DIMENSION_TEXTURE2D:
1238             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1239             wined3d_desc->u.texture.layer_idx = 0;
1240             wined3d_desc->u.texture.layer_count = 1;
1241             break;
1242
1243         case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:
1244             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1245             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1246             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1247             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1248             break;
1249
1250         case D3D11_DSV_DIMENSION_TEXTURE2DMS:
1251             wined3d_desc->u.texture.level_idx = 0;
1252             wined3d_desc->u.texture.layer_idx = 0;
1253             wined3d_desc->u.texture.layer_count = 1;
1254             break;
1255
1256         case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:
1257             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1258             wined3d_desc->u.texture.level_idx = 0;
1259             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1260             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1261             break;
1262
1263         default:
1264             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1265             wined3d_desc->u.texture.level_idx = 0;
1266             wined3d_desc->u.texture.layer_idx = 0;
1267             wined3d_desc->u.texture.layer_count = 1;
1268             break;
1269     }
1270 }
1271
1272 static HRESULT d3d_depthstencil_view_init(struct d3d_depthstencil_view *view, struct d3d_device *device,
1273         ID3D11Resource *resource, const D3D11_DEPTH_STENCIL_VIEW_DESC *desc)
1274 {
1275     struct wined3d_resource *wined3d_resource;
1276     struct wined3d_view_desc wined3d_desc;
1277     HRESULT hr;
1278
1279     view->ID3D11DepthStencilView_iface.lpVtbl = &d3d11_depthstencil_view_vtbl;
1280     view->ID3D10DepthStencilView_iface.lpVtbl = &d3d10_depthstencil_view_vtbl;
1281     view->refcount = 1;
1282
1283     if (!desc)
1284     {
1285         hr = set_dsv_desc_from_resource(&view->desc, resource);
1286     }
1287     else
1288     {
1289         view->desc = *desc;
1290         hr = normalize_dsv_desc(&view->desc, resource);
1291     }
1292     if (FAILED(hr))
1293         return hr;
1294
1295     wined3d_mutex_lock();
1296     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1297     {
1298         wined3d_mutex_unlock();
1299         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1300         return E_FAIL;
1301     }
1302
1303     wined3d_depth_stencil_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1304     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1305             view, &d3d_depth_stencil_view_wined3d_parent_ops, &view->wined3d_view)))
1306     {
1307         wined3d_mutex_unlock();
1308         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1309         return hr;
1310     }
1311
1312     wined3d_private_store_init(&view->private_store);
1313     wined3d_mutex_unlock();
1314     view->resource = resource;
1315     ID3D11Device2_AddRef(view->device = &device->ID3D11Device2_iface);
1316
1317     return S_OK;
1318 }
1319
1320 HRESULT d3d_depthstencil_view_create(struct d3d_device *device, ID3D11Resource *resource,
1321         const D3D11_DEPTH_STENCIL_VIEW_DESC *desc, struct d3d_depthstencil_view **view)
1322 {
1323     struct d3d_depthstencil_view *object;
1324     HRESULT hr;
1325
1326     if (!(object = heap_alloc_zero(sizeof(*object))))
1327         return E_OUTOFMEMORY;
1328
1329     if (FAILED(hr = d3d_depthstencil_view_init(object, device, resource, desc)))
1330     {
1331         WARN("Failed to initialize depthstencil view, hr %#x.\n", hr);
1332         heap_free(object);
1333         return hr;
1334     }
1335
1336     TRACE("Created depthstencil view %p.\n", object);
1337     *view = object;
1338
1339     return S_OK;
1340 }
1341
1342 struct d3d_depthstencil_view *unsafe_impl_from_ID3D11DepthStencilView(ID3D11DepthStencilView *iface)
1343 {
1344     if (!iface)
1345         return NULL;
1346     assert(iface->lpVtbl == &d3d11_depthstencil_view_vtbl);
1347
1348     return impl_from_ID3D11DepthStencilView(iface);
1349 }
1350
1351 struct d3d_depthstencil_view *unsafe_impl_from_ID3D10DepthStencilView(ID3D10DepthStencilView *iface)
1352 {
1353     if (!iface)
1354         return NULL;
1355     assert(iface->lpVtbl == &d3d10_depthstencil_view_vtbl);
1356
1357     return impl_from_ID3D10DepthStencilView(iface);
1358 }
1359
1360 /* ID3D11RenderTargetView methods */
1361
1362 static inline struct d3d_rendertarget_view *impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1363 {
1364     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D11RenderTargetView_iface);
1365 }
1366
1367 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_QueryInterface(ID3D11RenderTargetView *iface,
1368         REFIID riid, void **object)
1369 {
1370     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1371
1372     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1373
1374     if (IsEqualGUID(riid, &IID_ID3D11RenderTargetView)
1375             || IsEqualGUID(riid, &IID_ID3D11View)
1376             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1377             || IsEqualGUID(riid, &IID_IUnknown))
1378     {
1379         ID3D11RenderTargetView_AddRef(iface);
1380         *object = iface;
1381         return S_OK;
1382     }
1383
1384     if (IsEqualGUID(riid, &IID_ID3D10RenderTargetView)
1385             || IsEqualGUID(riid, &IID_ID3D10View)
1386             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1387     {
1388         ID3D10RenderTargetView_AddRef(&view->ID3D10RenderTargetView_iface);
1389         *object = &view->ID3D10RenderTargetView_iface;
1390         return S_OK;
1391     }
1392
1393     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1394
1395     *object = NULL;
1396     return E_NOINTERFACE;
1397 }
1398
1399 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_AddRef(ID3D11RenderTargetView *iface)
1400 {
1401     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1402     ULONG refcount = InterlockedIncrement(&view->refcount);
1403
1404     TRACE("%p increasing refcount to %u.\n", view, refcount);
1405
1406     if (refcount == 1)
1407     {
1408         ID3D11Device2_AddRef(view->device);
1409         wined3d_mutex_lock();
1410         wined3d_rendertarget_view_incref(view->wined3d_view);
1411         wined3d_mutex_unlock();
1412     }
1413
1414     return refcount;
1415 }
1416
1417 static ULONG STDMETHODCALLTYPE d3d11_rendertarget_view_Release(ID3D11RenderTargetView *iface)
1418 {
1419     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1420     ULONG refcount = InterlockedDecrement(&view->refcount);
1421
1422     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1423
1424     if (!refcount)
1425     {
1426         ID3D11Device2 *device = view->device;
1427
1428         wined3d_mutex_lock();
1429         wined3d_rendertarget_view_decref(view->wined3d_view);
1430         wined3d_mutex_unlock();
1431
1432         ID3D11Device2_Release(device);
1433     }
1434
1435     return refcount;
1436 }
1437
1438 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDevice(ID3D11RenderTargetView *iface,
1439         ID3D11Device **device)
1440 {
1441     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1442
1443     TRACE("iface %p, device %p.\n", iface, device);
1444
1445     *device = (ID3D11Device *)view->device;
1446     ID3D11Device_AddRef(*device);
1447 }
1448
1449 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_GetPrivateData(ID3D11RenderTargetView *iface,
1450         REFGUID guid, UINT *data_size, void *data)
1451 {
1452     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1453
1454     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1455
1456     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1457 }
1458
1459 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateData(ID3D11RenderTargetView *iface,
1460         REFGUID guid, UINT data_size, const void *data)
1461 {
1462     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1463
1464     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1465
1466     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1467 }
1468
1469 static HRESULT STDMETHODCALLTYPE d3d11_rendertarget_view_SetPrivateDataInterface(ID3D11RenderTargetView *iface,
1470         REFGUID guid, const IUnknown *data)
1471 {
1472     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1473
1474     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1475
1476     return d3d_set_private_data_interface(&view->private_store, guid, data);
1477 }
1478
1479 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetResource(ID3D11RenderTargetView *iface,
1480         ID3D11Resource **resource)
1481 {
1482     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1483
1484     TRACE("iface %p, resource %p.\n", iface, resource);
1485
1486     *resource = view->resource;
1487     ID3D11Resource_AddRef(*resource);
1488 }
1489
1490 static void STDMETHODCALLTYPE d3d11_rendertarget_view_GetDesc(ID3D11RenderTargetView *iface,
1491         D3D11_RENDER_TARGET_VIEW_DESC *desc)
1492 {
1493     struct d3d_rendertarget_view *view = impl_from_ID3D11RenderTargetView(iface);
1494
1495     TRACE("iface %p, desc %p.\n", iface, desc);
1496
1497     *desc = view->desc;
1498 }
1499
1500 static const struct ID3D11RenderTargetViewVtbl d3d11_rendertarget_view_vtbl =
1501 {
1502     /* IUnknown methods */
1503     d3d11_rendertarget_view_QueryInterface,
1504     d3d11_rendertarget_view_AddRef,
1505     d3d11_rendertarget_view_Release,
1506     /* ID3D11DeviceChild methods */
1507     d3d11_rendertarget_view_GetDevice,
1508     d3d11_rendertarget_view_GetPrivateData,
1509     d3d11_rendertarget_view_SetPrivateData,
1510     d3d11_rendertarget_view_SetPrivateDataInterface,
1511     /* ID3D11View methods */
1512     d3d11_rendertarget_view_GetResource,
1513     /* ID3D11RenderTargetView methods */
1514     d3d11_rendertarget_view_GetDesc,
1515 };
1516
1517 /* ID3D10RenderTargetView methods */
1518
1519 static inline struct d3d_rendertarget_view *impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1520 {
1521     return CONTAINING_RECORD(iface, struct d3d_rendertarget_view, ID3D10RenderTargetView_iface);
1522 }
1523
1524 /* IUnknown methods */
1525
1526 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_QueryInterface(ID3D10RenderTargetView *iface,
1527         REFIID riid, void **object)
1528 {
1529     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1530
1531     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1532
1533     return d3d11_rendertarget_view_QueryInterface(&view->ID3D11RenderTargetView_iface, riid, object);
1534 }
1535
1536 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_AddRef(ID3D10RenderTargetView *iface)
1537 {
1538     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1539
1540     TRACE("iface %p.\n", iface);
1541
1542     return d3d11_rendertarget_view_AddRef(&view->ID3D11RenderTargetView_iface);
1543 }
1544
1545 static ULONG STDMETHODCALLTYPE d3d10_rendertarget_view_Release(ID3D10RenderTargetView *iface)
1546 {
1547     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1548
1549     TRACE("iface %p.\n", iface);
1550
1551     return d3d11_rendertarget_view_Release(&view->ID3D11RenderTargetView_iface);
1552 }
1553
1554 /* ID3D10DeviceChild methods */
1555
1556 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDevice(ID3D10RenderTargetView *iface, ID3D10Device **device)
1557 {
1558     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1559
1560     TRACE("iface %p, device %p.\n", iface, device);
1561
1562     ID3D11Device2_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
1563 }
1564
1565 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_GetPrivateData(ID3D10RenderTargetView *iface,
1566         REFGUID guid, UINT *data_size, void *data)
1567 {
1568     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1569
1570     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
1571             iface, debugstr_guid(guid), data_size, data);
1572
1573     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1574 }
1575
1576 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateData(ID3D10RenderTargetView *iface,
1577         REFGUID guid, UINT data_size, const void *data)
1578 {
1579     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1580
1581     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
1582             iface, debugstr_guid(guid), data_size, data);
1583
1584     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1585 }
1586
1587 static HRESULT STDMETHODCALLTYPE d3d10_rendertarget_view_SetPrivateDataInterface(ID3D10RenderTargetView *iface,
1588         REFGUID guid, const IUnknown *data)
1589 {
1590     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1591
1592     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1593
1594     return d3d_set_private_data_interface(&view->private_store, guid, data);
1595 }
1596
1597 /* ID3D10View methods */
1598
1599 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetResource(ID3D10RenderTargetView *iface,
1600         ID3D10Resource **resource)
1601 {
1602     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1603
1604     TRACE("iface %p, resource %p\n", iface, resource);
1605
1606     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
1607 }
1608
1609 /* ID3D10RenderTargetView methods */
1610
1611 static void STDMETHODCALLTYPE d3d10_rendertarget_view_GetDesc(ID3D10RenderTargetView *iface,
1612         D3D10_RENDER_TARGET_VIEW_DESC *desc)
1613 {
1614     struct d3d_rendertarget_view *view = impl_from_ID3D10RenderTargetView(iface);
1615
1616     TRACE("iface %p, desc %p\n", iface, desc);
1617
1618     memcpy(desc, &view->desc, sizeof(*desc));
1619 }
1620
1621 static const struct ID3D10RenderTargetViewVtbl d3d10_rendertarget_view_vtbl =
1622 {
1623     /* IUnknown methods */
1624     d3d10_rendertarget_view_QueryInterface,
1625     d3d10_rendertarget_view_AddRef,
1626     d3d10_rendertarget_view_Release,
1627     /* ID3D10DeviceChild methods */
1628     d3d10_rendertarget_view_GetDevice,
1629     d3d10_rendertarget_view_GetPrivateData,
1630     d3d10_rendertarget_view_SetPrivateData,
1631     d3d10_rendertarget_view_SetPrivateDataInterface,
1632     /* ID3D10View methods */
1633     d3d10_rendertarget_view_GetResource,
1634     /* ID3D10RenderTargetView methods */
1635     d3d10_rendertarget_view_GetDesc,
1636 };
1637
1638 static void STDMETHODCALLTYPE d3d_render_target_view_wined3d_object_destroyed(void *parent)
1639 {
1640     struct d3d_rendertarget_view *view = parent;
1641
1642     wined3d_private_store_cleanup(&view->private_store);
1643     heap_free(parent);
1644 }
1645
1646 static const struct wined3d_parent_ops d3d_render_target_view_wined3d_parent_ops =
1647 {
1648     d3d_render_target_view_wined3d_object_destroyed,
1649 };
1650
1651 static void wined3d_rendertarget_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
1652         const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1653 {
1654     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
1655
1656     wined3d_desc->flags = 0;
1657     wined3d_desc->u.texture.level_count = 1;
1658     switch (desc->ViewDimension)
1659     {
1660         case D3D11_RTV_DIMENSION_BUFFER:
1661             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
1662             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
1663             break;
1664
1665         case D3D11_RTV_DIMENSION_TEXTURE1D:
1666             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
1667             wined3d_desc->u.texture.layer_idx = 0;
1668             wined3d_desc->u.texture.layer_count = 1;
1669             break;
1670
1671         case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:
1672             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1673             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
1674             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
1675             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
1676             break;
1677
1678         case D3D11_RTV_DIMENSION_TEXTURE2D:
1679             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
1680             wined3d_desc->u.texture.layer_idx = 0;
1681             wined3d_desc->u.texture.layer_count = 1;
1682             break;
1683
1684         case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:
1685             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1686             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
1687             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
1688             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
1689             break;
1690
1691         case D3D11_RTV_DIMENSION_TEXTURE2DMS:
1692             wined3d_desc->u.texture.level_idx = 0;
1693             wined3d_desc->u.texture.layer_idx = 0;
1694             wined3d_desc->u.texture.layer_count = 1;
1695             break;
1696
1697         case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:
1698             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
1699             wined3d_desc->u.texture.level_idx = 0;
1700             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
1701             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
1702             break;
1703
1704         case D3D11_RTV_DIMENSION_TEXTURE3D:
1705             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
1706             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
1707             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
1708             break;
1709
1710         default:
1711             FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension);
1712             wined3d_desc->u.texture.level_idx = 0;
1713             wined3d_desc->u.texture.layer_idx = 0;
1714             wined3d_desc->u.texture.layer_count = 1;
1715             break;
1716     }
1717 }
1718
1719 static HRESULT d3d_rendertarget_view_init(struct d3d_rendertarget_view *view, struct d3d_device *device,
1720         ID3D11Resource *resource, const D3D11_RENDER_TARGET_VIEW_DESC *desc)
1721 {
1722     struct wined3d_resource *wined3d_resource;
1723     struct wined3d_view_desc wined3d_desc;
1724     HRESULT hr;
1725
1726     view->ID3D11RenderTargetView_iface.lpVtbl = &d3d11_rendertarget_view_vtbl;
1727     view->ID3D10RenderTargetView_iface.lpVtbl = &d3d10_rendertarget_view_vtbl;
1728     view->refcount = 1;
1729
1730     if (!desc)
1731     {
1732         hr = set_rtv_desc_from_resource(&view->desc, resource);
1733     }
1734     else
1735     {
1736         view->desc = *desc;
1737         hr = normalize_rtv_desc(&view->desc, resource);
1738     }
1739     if (FAILED(hr))
1740         return hr;
1741
1742     wined3d_mutex_lock();
1743     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
1744     {
1745         wined3d_mutex_unlock();
1746         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
1747         return E_FAIL;
1748     }
1749
1750     wined3d_rendertarget_view_desc_from_d3d11(&wined3d_desc, &view->desc);
1751     if (FAILED(hr = wined3d_rendertarget_view_create(&wined3d_desc, wined3d_resource,
1752             view, &d3d_render_target_view_wined3d_parent_ops, &view->wined3d_view)))
1753     {
1754         wined3d_mutex_unlock();
1755         WARN("Failed to create a wined3d rendertarget view, hr %#x.\n", hr);
1756         return hr;
1757     }
1758
1759     wined3d_private_store_init(&view->private_store);
1760     wined3d_mutex_unlock();
1761     view->resource = resource;
1762     ID3D11Device2_AddRef(view->device = &device->ID3D11Device2_iface);
1763
1764     return S_OK;
1765 }
1766
1767 HRESULT d3d_rendertarget_view_create(struct d3d_device *device, ID3D11Resource *resource,
1768         const D3D11_RENDER_TARGET_VIEW_DESC *desc, struct d3d_rendertarget_view **view)
1769 {
1770     struct d3d_rendertarget_view *object;
1771     HRESULT hr;
1772
1773     if (!(object = heap_alloc_zero(sizeof(*object))))
1774         return E_OUTOFMEMORY;
1775
1776     if (FAILED(hr = d3d_rendertarget_view_init(object, device, resource, desc)))
1777     {
1778         WARN("Failed to initialize rendertarget view, hr %#x.\n", hr);
1779         heap_free(object);
1780         return hr;
1781     }
1782
1783     TRACE("Created rendertarget view %p.\n", object);
1784     *view = object;
1785
1786     return S_OK;
1787 }
1788
1789 struct d3d_rendertarget_view *unsafe_impl_from_ID3D11RenderTargetView(ID3D11RenderTargetView *iface)
1790 {
1791     if (!iface)
1792         return NULL;
1793     assert(iface->lpVtbl == &d3d11_rendertarget_view_vtbl);
1794
1795     return impl_from_ID3D11RenderTargetView(iface);
1796 }
1797
1798 struct d3d_rendertarget_view *unsafe_impl_from_ID3D10RenderTargetView(ID3D10RenderTargetView *iface)
1799 {
1800     if (!iface)
1801         return NULL;
1802     assert(iface->lpVtbl == &d3d10_rendertarget_view_vtbl);
1803
1804     return impl_from_ID3D10RenderTargetView(iface);
1805 }
1806
1807 /* ID3D11ShaderResourceView methods */
1808
1809 static inline struct d3d_shader_resource_view *impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
1810 {
1811     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D11ShaderResourceView_iface);
1812 }
1813
1814 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_QueryInterface(ID3D11ShaderResourceView *iface,
1815         REFIID riid, void **object)
1816 {
1817     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1818
1819     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1820
1821     if (IsEqualGUID(riid, &IID_ID3D11ShaderResourceView)
1822             || IsEqualGUID(riid, &IID_ID3D11View)
1823             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
1824             || IsEqualGUID(riid, &IID_IUnknown))
1825     {
1826         ID3D11ShaderResourceView_AddRef(iface);
1827         *object = iface;
1828         return S_OK;
1829     }
1830
1831     if (IsEqualGUID(riid, &IID_ID3D10ShaderResourceView1)
1832             || IsEqualGUID(riid, &IID_ID3D10ShaderResourceView)
1833             || IsEqualGUID(riid, &IID_ID3D10View)
1834             || IsEqualGUID(riid, &IID_ID3D10DeviceChild))
1835     {
1836         ID3D10ShaderResourceView1_AddRef(&view->ID3D10ShaderResourceView1_iface);
1837         *object = &view->ID3D10ShaderResourceView1_iface;
1838         return S_OK;
1839     }
1840
1841     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
1842
1843     *object = NULL;
1844     return E_NOINTERFACE;
1845 }
1846
1847 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_AddRef(ID3D11ShaderResourceView *iface)
1848 {
1849     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1850     ULONG refcount = InterlockedIncrement(&view->refcount);
1851
1852     TRACE("%p increasing refcount to %u.\n", view, refcount);
1853
1854     if (refcount == 1)
1855     {
1856         ID3D11Device2_AddRef(view->device);
1857         wined3d_mutex_lock();
1858         wined3d_shader_resource_view_incref(view->wined3d_view);
1859         wined3d_mutex_unlock();
1860     }
1861
1862     return refcount;
1863 }
1864
1865 static ULONG STDMETHODCALLTYPE d3d11_shader_resource_view_Release(ID3D11ShaderResourceView *iface)
1866 {
1867     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1868     ULONG refcount = InterlockedDecrement(&view->refcount);
1869
1870     TRACE("%p decreasing refcount to %u.\n", view, refcount);
1871
1872     if (!refcount)
1873     {
1874         ID3D11Device2 *device = view->device;
1875
1876         wined3d_mutex_lock();
1877         wined3d_shader_resource_view_decref(view->wined3d_view);
1878         wined3d_mutex_unlock();
1879
1880         ID3D11Device2_Release(device);
1881     }
1882
1883     return refcount;
1884 }
1885
1886 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDevice(ID3D11ShaderResourceView *iface,
1887         ID3D11Device **device)
1888 {
1889     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1890
1891     TRACE("iface %p, device %p.\n", iface, device);
1892
1893     *device = (ID3D11Device *)view->device;
1894     ID3D11Device_AddRef(*device);
1895 }
1896
1897 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_GetPrivateData(ID3D11ShaderResourceView *iface,
1898         REFGUID guid, UINT *data_size, void *data)
1899 {
1900     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1901
1902     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1903
1904     return d3d_get_private_data(&view->private_store, guid, data_size, data);
1905 }
1906
1907 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateData(ID3D11ShaderResourceView *iface,
1908         REFGUID guid, UINT data_size, const void *data)
1909 {
1910     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1911
1912     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
1913
1914     return d3d_set_private_data(&view->private_store, guid, data_size, data);
1915 }
1916
1917 static HRESULT STDMETHODCALLTYPE d3d11_shader_resource_view_SetPrivateDataInterface(ID3D11ShaderResourceView *iface,
1918         REFGUID guid, const IUnknown *data)
1919 {
1920     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1921
1922     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
1923
1924     return d3d_set_private_data_interface(&view->private_store, guid, data);
1925 }
1926
1927 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetResource(ID3D11ShaderResourceView *iface,
1928         ID3D11Resource **resource)
1929 {
1930     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1931
1932     TRACE("iface %p, resource %p.\n", iface, resource);
1933
1934     *resource = view->resource;
1935     ID3D11Resource_AddRef(*resource);
1936 }
1937
1938 static void STDMETHODCALLTYPE d3d11_shader_resource_view_GetDesc(ID3D11ShaderResourceView *iface,
1939         D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
1940 {
1941     struct d3d_shader_resource_view *view = impl_from_ID3D11ShaderResourceView(iface);
1942
1943     TRACE("iface %p, desc %p.\n", iface, desc);
1944
1945     *desc = view->desc;
1946 }
1947
1948 static const struct ID3D11ShaderResourceViewVtbl d3d11_shader_resource_view_vtbl =
1949 {
1950     /* IUnknown methods */
1951     d3d11_shader_resource_view_QueryInterface,
1952     d3d11_shader_resource_view_AddRef,
1953     d3d11_shader_resource_view_Release,
1954     /* ID3D11DeviceChild methods */
1955     d3d11_shader_resource_view_GetDevice,
1956     d3d11_shader_resource_view_GetPrivateData,
1957     d3d11_shader_resource_view_SetPrivateData,
1958     d3d11_shader_resource_view_SetPrivateDataInterface,
1959     /* ID3D11View methods */
1960     d3d11_shader_resource_view_GetResource,
1961     /* ID3D11ShaderResourceView methods */
1962     d3d11_shader_resource_view_GetDesc,
1963 };
1964
1965 /* ID3D10ShaderResourceView methods */
1966
1967 static inline struct d3d_shader_resource_view *impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView1 *iface)
1968 {
1969     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
1970 }
1971
1972 /* IUnknown methods */
1973
1974 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_QueryInterface(ID3D10ShaderResourceView1 *iface,
1975         REFIID riid, void **object)
1976 {
1977     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1978
1979     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
1980
1981     return d3d11_shader_resource_view_QueryInterface(&view->ID3D11ShaderResourceView_iface, riid, object);
1982 }
1983
1984 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_AddRef(ID3D10ShaderResourceView1 *iface)
1985 {
1986     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1987
1988     TRACE("iface %p.\n", iface);
1989
1990     return d3d11_shader_resource_view_AddRef(&view->ID3D11ShaderResourceView_iface);
1991 }
1992
1993 static ULONG STDMETHODCALLTYPE d3d10_shader_resource_view_Release(ID3D10ShaderResourceView1 *iface)
1994 {
1995     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
1996
1997     TRACE("iface %p.\n", iface);
1998
1999     return d3d11_shader_resource_view_Release(&view->ID3D11ShaderResourceView_iface);
2000 }
2001
2002 /* ID3D10DeviceChild methods */
2003
2004 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDevice(ID3D10ShaderResourceView1 *iface,
2005         ID3D10Device **device)
2006 {
2007     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2008
2009     TRACE("iface %p, device %p.\n", iface, device);
2010
2011     ID3D11Device2_QueryInterface(view->device, &IID_ID3D10Device, (void **)device);
2012 }
2013
2014 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_GetPrivateData(ID3D10ShaderResourceView1 *iface,
2015         REFGUID guid, UINT *data_size, void *data)
2016 {
2017     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2018
2019     TRACE("iface %p, guid %s, data_size %p, data %p.\n",
2020             iface, debugstr_guid(guid), data_size, data);
2021
2022     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2023 }
2024
2025 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateData(ID3D10ShaderResourceView1 *iface,
2026         REFGUID guid, UINT data_size, const void *data)
2027 {
2028     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2029
2030     TRACE("iface %p, guid %s, data_size %u, data %p.\n",
2031             iface, debugstr_guid(guid), data_size, data);
2032
2033     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2034 }
2035
2036 static HRESULT STDMETHODCALLTYPE d3d10_shader_resource_view_SetPrivateDataInterface(ID3D10ShaderResourceView1 *iface,
2037         REFGUID guid, const IUnknown *data)
2038 {
2039     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2040
2041     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2042
2043     return d3d_set_private_data_interface(&view->private_store, guid, data);
2044 }
2045
2046 /* ID3D10View methods */
2047
2048 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetResource(ID3D10ShaderResourceView1 *iface,
2049         ID3D10Resource **resource)
2050 {
2051     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2052
2053     TRACE("iface %p, resource %p.\n", iface, resource);
2054
2055     ID3D11Resource_QueryInterface(view->resource, &IID_ID3D10Resource, (void **)resource);
2056 }
2057
2058 /* ID3D10ShaderResourceView methods */
2059
2060 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc(ID3D10ShaderResourceView1 *iface,
2061         D3D10_SHADER_RESOURCE_VIEW_DESC *desc)
2062 {
2063     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2064
2065     TRACE("iface %p, desc %p.\n", iface, desc);
2066
2067     memcpy(desc, &view->desc, sizeof(*desc));
2068 }
2069
2070 static void STDMETHODCALLTYPE d3d10_shader_resource_view_GetDesc1(ID3D10ShaderResourceView1 *iface,
2071         D3D10_SHADER_RESOURCE_VIEW_DESC1 *desc)
2072 {
2073     struct d3d_shader_resource_view *view = impl_from_ID3D10ShaderResourceView(iface);
2074
2075     TRACE("iface %p, desc %p.\n", iface, desc);
2076
2077     memcpy(desc, &view->desc, sizeof(*desc));
2078 }
2079
2080 static const struct ID3D10ShaderResourceView1Vtbl d3d10_shader_resource_view_vtbl =
2081 {
2082     /* IUnknown methods */
2083     d3d10_shader_resource_view_QueryInterface,
2084     d3d10_shader_resource_view_AddRef,
2085     d3d10_shader_resource_view_Release,
2086     /* ID3D10DeviceChild methods */
2087     d3d10_shader_resource_view_GetDevice,
2088     d3d10_shader_resource_view_GetPrivateData,
2089     d3d10_shader_resource_view_SetPrivateData,
2090     d3d10_shader_resource_view_SetPrivateDataInterface,
2091     /* ID3D10View methods */
2092     d3d10_shader_resource_view_GetResource,
2093     /* ID3D10ShaderResourceView methods */
2094     d3d10_shader_resource_view_GetDesc,
2095     /* ID3D10ShaderResourceView1 methods */
2096     d3d10_shader_resource_view_GetDesc1,
2097 };
2098
2099 static void STDMETHODCALLTYPE d3d_shader_resource_view_wined3d_object_destroyed(void *parent)
2100 {
2101     struct d3d_shader_resource_view *view = parent;
2102
2103     wined3d_private_store_cleanup(&view->private_store);
2104     heap_free(parent);
2105 }
2106
2107 static const struct wined3d_parent_ops d3d_shader_resource_view_wined3d_parent_ops =
2108 {
2109     d3d_shader_resource_view_wined3d_object_destroyed,
2110 };
2111
2112 static unsigned int wined3d_view_flags_from_d3d11_bufferex_flags(unsigned int d3d11_flags)
2113 {
2114     unsigned int wined3d_flags = d3d11_flags & WINED3D_VIEW_BUFFER_RAW;
2115
2116     if (d3d11_flags != wined3d_flags)
2117         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2118
2119     return wined3d_flags;
2120 }
2121
2122 static HRESULT wined3d_shader_resource_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
2123         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2124 {
2125     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2126     wined3d_desc->flags = 0;
2127
2128     switch (desc->ViewDimension)
2129     {
2130         case D3D11_SRV_DIMENSION_BUFFER:
2131             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.u1.FirstElement;
2132             wined3d_desc->u.buffer.count = desc->u.Buffer.u2.NumElements;
2133             break;
2134
2135         case D3D11_SRV_DIMENSION_TEXTURE1D:
2136             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MostDetailedMip;
2137             wined3d_desc->u.texture.level_count = desc->u.Texture1D.MipLevels;
2138             wined3d_desc->u.texture.layer_idx = 0;
2139             wined3d_desc->u.texture.layer_count = 1;
2140             break;
2141
2142         case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
2143             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2144             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MostDetailedMip;
2145             wined3d_desc->u.texture.level_count = desc->u.Texture1DArray.MipLevels;
2146             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2147             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2148             break;
2149
2150         case D3D11_SRV_DIMENSION_TEXTURE2D:
2151             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MostDetailedMip;
2152             wined3d_desc->u.texture.level_count = desc->u.Texture2D.MipLevels;
2153             wined3d_desc->u.texture.layer_idx = 0;
2154             wined3d_desc->u.texture.layer_count = 1;
2155             break;
2156
2157         case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
2158             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2159             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MostDetailedMip;
2160             wined3d_desc->u.texture.level_count = desc->u.Texture2DArray.MipLevels;
2161             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2162             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2163             break;
2164
2165         case D3D11_SRV_DIMENSION_TEXTURE2DMS:
2166             wined3d_desc->u.texture.level_idx = 0;
2167             wined3d_desc->u.texture.level_count = 1;
2168             wined3d_desc->u.texture.layer_idx = 0;
2169             wined3d_desc->u.texture.layer_count = 1;
2170             break;
2171
2172         case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
2173             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2174             wined3d_desc->u.texture.level_idx = 0;
2175             wined3d_desc->u.texture.level_count = 1;
2176             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DMSArray.FirstArraySlice;
2177             wined3d_desc->u.texture.layer_count = desc->u.Texture2DMSArray.ArraySize;
2178             break;
2179
2180         case D3D11_SRV_DIMENSION_TEXTURE3D:
2181             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MostDetailedMip;
2182             wined3d_desc->u.texture.level_count = desc->u.Texture3D.MipLevels;
2183             wined3d_desc->u.texture.layer_idx = 0;
2184             wined3d_desc->u.texture.layer_count = 1;
2185             break;
2186
2187         case D3D11_SRV_DIMENSION_TEXTURECUBE:
2188             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE;
2189             wined3d_desc->u.texture.level_idx = desc->u.TextureCube.MostDetailedMip;
2190             wined3d_desc->u.texture.level_count = desc->u.TextureCube.MipLevels;
2191             wined3d_desc->u.texture.layer_idx = 0;
2192             wined3d_desc->u.texture.layer_count = 6;
2193             break;
2194
2195         case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
2196             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_CUBE | WINED3D_VIEW_TEXTURE_ARRAY;
2197             wined3d_desc->u.texture.level_idx = desc->u.TextureCubeArray.MostDetailedMip;
2198             wined3d_desc->u.texture.level_count = desc->u.TextureCubeArray.MipLevels;
2199             wined3d_desc->u.texture.layer_idx = desc->u.TextureCubeArray.First2DArrayFace;
2200             wined3d_desc->u.texture.layer_count = 6 * desc->u.TextureCubeArray.NumCubes;
2201             break;
2202
2203         case D3D11_SRV_DIMENSION_BUFFEREX:
2204             wined3d_desc->flags = wined3d_view_flags_from_d3d11_bufferex_flags(desc->u.BufferEx.Flags);
2205             wined3d_desc->u.buffer.start_idx = desc->u.BufferEx.FirstElement;
2206             wined3d_desc->u.buffer.count = desc->u.BufferEx.NumElements;
2207             break;
2208
2209         default:
2210             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2211             return E_FAIL;
2212     }
2213
2214     return S_OK;
2215 }
2216
2217 static HRESULT d3d_shader_resource_view_init(struct d3d_shader_resource_view *view, struct d3d_device *device,
2218         ID3D11Resource *resource, const D3D11_SHADER_RESOURCE_VIEW_DESC *desc)
2219 {
2220     struct wined3d_resource *wined3d_resource;
2221     struct wined3d_view_desc wined3d_desc;
2222     HRESULT hr;
2223
2224     view->ID3D11ShaderResourceView_iface.lpVtbl = &d3d11_shader_resource_view_vtbl;
2225     view->ID3D10ShaderResourceView1_iface.lpVtbl = &d3d10_shader_resource_view_vtbl;
2226     view->refcount = 1;
2227
2228     if (!desc)
2229     {
2230         hr = set_srv_desc_from_resource(&view->desc, resource);
2231     }
2232     else
2233     {
2234         view->desc = *desc;
2235         hr = normalize_srv_desc(&view->desc, resource);
2236     }
2237     if (FAILED(hr))
2238         return hr;
2239
2240     if (FAILED(hr = wined3d_shader_resource_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2241         return hr;
2242
2243     wined3d_mutex_lock();
2244     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2245     {
2246         wined3d_mutex_unlock();
2247         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2248         return E_FAIL;
2249     }
2250
2251     if (FAILED(hr = wined3d_shader_resource_view_create(&wined3d_desc, wined3d_resource,
2252             view, &d3d_shader_resource_view_wined3d_parent_ops, &view->wined3d_view)))
2253     {
2254         wined3d_mutex_unlock();
2255         WARN("Failed to create wined3d shader resource view, hr %#x.\n", hr);
2256         return hr;
2257     }
2258
2259     wined3d_private_store_init(&view->private_store);
2260     wined3d_mutex_unlock();
2261     view->resource = resource;
2262     ID3D11Device2_AddRef(view->device = &device->ID3D11Device2_iface);
2263
2264     return S_OK;
2265 }
2266
2267 HRESULT d3d_shader_resource_view_create(struct d3d_device *device, ID3D11Resource *resource,
2268         const D3D11_SHADER_RESOURCE_VIEW_DESC *desc, struct d3d_shader_resource_view **view)
2269 {
2270     struct d3d_shader_resource_view *object;
2271     HRESULT hr;
2272
2273     if (!(object = heap_alloc_zero(sizeof(*object))))
2274         return E_OUTOFMEMORY;
2275
2276     if (FAILED(hr = d3d_shader_resource_view_init(object, device, resource, desc)))
2277     {
2278         WARN("Failed to initialize shader resource view, hr %#x.\n", hr);
2279         heap_free(object);
2280         return hr;
2281     }
2282
2283     TRACE("Created shader resource view %p.\n", object);
2284     *view = object;
2285
2286     return S_OK;
2287 }
2288
2289 struct d3d_shader_resource_view *unsafe_impl_from_ID3D11ShaderResourceView(ID3D11ShaderResourceView *iface)
2290 {
2291     if (!iface)
2292         return NULL;
2293     assert(iface->lpVtbl == &d3d11_shader_resource_view_vtbl);
2294     return impl_from_ID3D11ShaderResourceView(iface);
2295 }
2296
2297 struct d3d_shader_resource_view *unsafe_impl_from_ID3D10ShaderResourceView(ID3D10ShaderResourceView *iface)
2298 {
2299     if (!iface)
2300         return NULL;
2301     assert(iface->lpVtbl == (ID3D10ShaderResourceViewVtbl *)&d3d10_shader_resource_view_vtbl);
2302     return CONTAINING_RECORD(iface, struct d3d_shader_resource_view, ID3D10ShaderResourceView1_iface);
2303 }
2304
2305 /* ID3D11UnorderedAccessView methods */
2306
2307 static inline struct d3d11_unordered_access_view *impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2308 {
2309     return CONTAINING_RECORD(iface, struct d3d11_unordered_access_view, ID3D11UnorderedAccessView_iface);
2310 }
2311
2312 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_QueryInterface(ID3D11UnorderedAccessView *iface,
2313         REFIID riid, void **object)
2314 {
2315     TRACE("iface %p, riid %s, object %p.\n", iface, debugstr_guid(riid), object);
2316
2317     if (IsEqualGUID(riid, &IID_ID3D11UnorderedAccessView)
2318             || IsEqualGUID(riid, &IID_ID3D11View)
2319             || IsEqualGUID(riid, &IID_ID3D11DeviceChild)
2320             || IsEqualGUID(riid, &IID_IUnknown))
2321     {
2322         ID3D11UnorderedAccessView_AddRef(*object = iface);
2323         return S_OK;
2324     }
2325
2326     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(riid));
2327
2328     *object = NULL;
2329     return E_NOINTERFACE;
2330 }
2331
2332 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_AddRef(ID3D11UnorderedAccessView *iface)
2333 {
2334     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2335     ULONG refcount = InterlockedIncrement(&view->refcount);
2336
2337     TRACE("%p increasing refcount to %u.\n", view, refcount);
2338
2339     if (refcount == 1)
2340     {
2341         ID3D11Device2_AddRef(view->device);
2342         wined3d_mutex_lock();
2343         wined3d_unordered_access_view_incref(view->wined3d_view);
2344         wined3d_mutex_unlock();
2345     }
2346
2347     return refcount;
2348 }
2349
2350 static ULONG STDMETHODCALLTYPE d3d11_unordered_access_view_Release(ID3D11UnorderedAccessView *iface)
2351 {
2352     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2353     ULONG refcount = InterlockedDecrement(&view->refcount);
2354
2355     TRACE("%p decreasing refcount to %u.\n", view, refcount);
2356
2357     if (!refcount)
2358     {
2359         ID3D11Device2 *device = view->device;
2360
2361         wined3d_mutex_lock();
2362         wined3d_unordered_access_view_decref(view->wined3d_view);
2363         wined3d_mutex_unlock();
2364
2365         ID3D11Device2_Release(device);
2366     }
2367
2368     return refcount;
2369 }
2370
2371 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDevice(ID3D11UnorderedAccessView *iface,
2372         ID3D11Device **device)
2373 {
2374     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2375
2376     TRACE("iface %p, device %p.\n", iface, device);
2377
2378     ID3D11Device_AddRef(*device = (ID3D11Device *)view->device);
2379 }
2380
2381 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_GetPrivateData(ID3D11UnorderedAccessView *iface,
2382         REFGUID guid, UINT *data_size, void *data)
2383 {
2384     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2385
2386     TRACE("iface %p, guid %s, data_size %p, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2387
2388     return d3d_get_private_data(&view->private_store, guid, data_size, data);
2389 }
2390
2391 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateData(ID3D11UnorderedAccessView *iface,
2392         REFGUID guid, UINT data_size, const void *data)
2393 {
2394     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2395
2396     TRACE("iface %p, guid %s, data_size %u, data %p.\n", iface, debugstr_guid(guid), data_size, data);
2397
2398     return d3d_set_private_data(&view->private_store, guid, data_size, data);
2399 }
2400
2401 static HRESULT STDMETHODCALLTYPE d3d11_unordered_access_view_SetPrivateDataInterface(ID3D11UnorderedAccessView *iface,
2402         REFGUID guid, const IUnknown *data)
2403 {
2404     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2405
2406     TRACE("iface %p, guid %s, data %p.\n", iface, debugstr_guid(guid), data);
2407
2408     return d3d_set_private_data_interface(&view->private_store, guid, data);
2409 }
2410
2411 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetResource(ID3D11UnorderedAccessView *iface,
2412         ID3D11Resource **resource)
2413 {
2414     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2415
2416     TRACE("iface %p, resource %p.\n", iface, resource);
2417
2418     ID3D11Resource_AddRef(*resource = view->resource);
2419 }
2420
2421 static void STDMETHODCALLTYPE d3d11_unordered_access_view_GetDesc(ID3D11UnorderedAccessView *iface,
2422         D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2423 {
2424     struct d3d11_unordered_access_view *view = impl_from_ID3D11UnorderedAccessView(iface);
2425
2426     TRACE("iface %p, desc %p.\n", iface, desc);
2427
2428     *desc = view->desc;
2429 }
2430
2431 static const struct ID3D11UnorderedAccessViewVtbl d3d11_unordered_access_view_vtbl =
2432 {
2433     /* IUnknown methods */
2434     d3d11_unordered_access_view_QueryInterface,
2435     d3d11_unordered_access_view_AddRef,
2436     d3d11_unordered_access_view_Release,
2437     /* ID3D11DeviceChild methods */
2438     d3d11_unordered_access_view_GetDevice,
2439     d3d11_unordered_access_view_GetPrivateData,
2440     d3d11_unordered_access_view_SetPrivateData,
2441     d3d11_unordered_access_view_SetPrivateDataInterface,
2442     /* ID3D11View methods */
2443     d3d11_unordered_access_view_GetResource,
2444     /* ID3D11UnorderedAccessView methods */
2445     d3d11_unordered_access_view_GetDesc,
2446 };
2447
2448 static void STDMETHODCALLTYPE d3d11_unordered_access_view_wined3d_object_destroyed(void *parent)
2449 {
2450     struct d3d11_unordered_access_view *view = parent;
2451
2452     wined3d_private_store_cleanup(&view->private_store);
2453     heap_free(parent);
2454 }
2455
2456 static const struct wined3d_parent_ops d3d11_unordered_access_view_wined3d_parent_ops =
2457 {
2458     d3d11_unordered_access_view_wined3d_object_destroyed,
2459 };
2460
2461 static unsigned int wined3d_view_flags_from_d3d11_buffer_uav_flags(unsigned int d3d11_flags)
2462 {
2463     unsigned int wined3d_flags = d3d11_flags & (WINED3D_VIEW_BUFFER_RAW
2464             | WINED3D_VIEW_BUFFER_APPEND | WINED3D_VIEW_BUFFER_COUNTER);
2465
2466     if (d3d11_flags != wined3d_flags)
2467         FIXME("Unhandled flags %#x.\n", d3d11_flags & ~wined3d_flags);
2468
2469     return wined3d_flags;
2470 }
2471
2472 static HRESULT wined3d_unordered_access_view_desc_from_d3d11(struct wined3d_view_desc *wined3d_desc,
2473         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2474 {
2475     wined3d_desc->format_id = wined3dformat_from_dxgi_format(desc->Format);
2476
2477     wined3d_desc->flags = 0;
2478     wined3d_desc->u.texture.level_count = 1;
2479     switch (desc->ViewDimension)
2480     {
2481         case D3D11_UAV_DIMENSION_BUFFER:
2482             wined3d_desc->flags = wined3d_view_flags_from_d3d11_buffer_uav_flags(desc->u.Buffer.Flags);
2483             wined3d_desc->u.buffer.start_idx = desc->u.Buffer.FirstElement;
2484             wined3d_desc->u.buffer.count = desc->u.Buffer.NumElements;
2485             break;
2486
2487         case D3D11_UAV_DIMENSION_TEXTURE1D:
2488             wined3d_desc->u.texture.level_idx = desc->u.Texture1D.MipSlice;
2489             wined3d_desc->u.texture.layer_idx = 0;
2490             wined3d_desc->u.texture.layer_count = 1;
2491             break;
2492
2493         case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:
2494             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2495             wined3d_desc->u.texture.level_idx = desc->u.Texture1DArray.MipSlice;
2496             wined3d_desc->u.texture.layer_idx = desc->u.Texture1DArray.FirstArraySlice;
2497             wined3d_desc->u.texture.layer_count = desc->u.Texture1DArray.ArraySize;
2498             break;
2499
2500         case D3D11_UAV_DIMENSION_TEXTURE2D:
2501             wined3d_desc->u.texture.level_idx = desc->u.Texture2D.MipSlice;
2502             wined3d_desc->u.texture.layer_idx = 0;
2503             wined3d_desc->u.texture.layer_count = 1;
2504             break;
2505
2506         case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:
2507             wined3d_desc->flags = WINED3D_VIEW_TEXTURE_ARRAY;
2508             wined3d_desc->u.texture.level_idx = desc->u.Texture2DArray.MipSlice;
2509             wined3d_desc->u.texture.layer_idx = desc->u.Texture2DArray.FirstArraySlice;
2510             wined3d_desc->u.texture.layer_count = desc->u.Texture2DArray.ArraySize;
2511             break;
2512
2513         case D3D11_UAV_DIMENSION_TEXTURE3D:
2514             wined3d_desc->u.texture.level_idx = desc->u.Texture3D.MipSlice;
2515             wined3d_desc->u.texture.layer_idx = desc->u.Texture3D.FirstWSlice;
2516             wined3d_desc->u.texture.layer_count = desc->u.Texture3D.WSize;
2517             break;
2518
2519         default:
2520             WARN("Unrecognized view dimension %#x.\n", desc->ViewDimension);
2521             return E_FAIL;
2522     }
2523
2524     return S_OK;
2525 }
2526
2527 static HRESULT d3d11_unordered_access_view_init(struct d3d11_unordered_access_view *view,
2528         struct d3d_device *device, ID3D11Resource *resource, const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc)
2529 {
2530     struct wined3d_resource *wined3d_resource;
2531     struct wined3d_view_desc wined3d_desc;
2532     HRESULT hr;
2533
2534     view->ID3D11UnorderedAccessView_iface.lpVtbl = &d3d11_unordered_access_view_vtbl;
2535     view->refcount = 1;
2536
2537     if (!desc)
2538     {
2539         hr = set_uav_desc_from_resource(&view->desc, resource);
2540     }
2541     else
2542     {
2543         view->desc = *desc;
2544         hr = normalize_uav_desc(&view->desc, resource);
2545     }
2546     if (FAILED(hr))
2547         return hr;
2548
2549     if (FAILED(hr = wined3d_unordered_access_view_desc_from_d3d11(&wined3d_desc, &view->desc)))
2550         return hr;
2551
2552     wined3d_mutex_lock();
2553     if (!(wined3d_resource = wined3d_resource_from_d3d11_resource(resource)))
2554     {
2555         wined3d_mutex_unlock();
2556         ERR("Failed to get wined3d resource for d3d11 resource %p.\n", resource);
2557         return E_FAIL;
2558     }
2559
2560     if (FAILED(hr = wined3d_unordered_access_view_create(&wined3d_desc, wined3d_resource,
2561             view, &d3d11_unordered_access_view_wined3d_parent_ops, &view->wined3d_view)))
2562     {
2563         wined3d_mutex_unlock();
2564         WARN("Failed to create wined3d unordered access view, hr %#x.\n", hr);
2565         return hr;
2566     }
2567
2568     wined3d_private_store_init(&view->private_store);
2569     wined3d_mutex_unlock();
2570     view->resource = resource;
2571     ID3D11Device2_AddRef(view->device = &device->ID3D11Device2_iface);
2572
2573     return S_OK;
2574 }
2575
2576 HRESULT d3d11_unordered_access_view_create(struct d3d_device *device, ID3D11Resource *resource,
2577         const D3D11_UNORDERED_ACCESS_VIEW_DESC *desc, struct d3d11_unordered_access_view **view)
2578 {
2579     struct d3d11_unordered_access_view *object;
2580     HRESULT hr;
2581
2582     if (!(object = heap_alloc_zero(sizeof(*object))))
2583         return E_OUTOFMEMORY;
2584
2585     if (FAILED(hr = d3d11_unordered_access_view_init(object, device, resource, desc)))
2586     {
2587         WARN("Failed to initialize unordered access view, hr %#x.\n", hr);
2588         heap_free(object);
2589         return hr;
2590     }
2591
2592     TRACE("Created unordered access view %p.\n", object);
2593     *view = object;
2594
2595     return S_OK;
2596 }
2597
2598 struct d3d11_unordered_access_view *unsafe_impl_from_ID3D11UnorderedAccessView(ID3D11UnorderedAccessView *iface)
2599 {
2600     if (!iface)
2601         return NULL;
2602     assert(iface->lpVtbl == &d3d11_unordered_access_view_vtbl);
2603
2604     return impl_from_ID3D11UnorderedAccessView(iface);
2605 }