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