src/vulkan/anv_image.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include <assert.h>
  25 #include <stdbool.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #include "anv_private.h"
  31
  32 static const uint8_t anv_halign[] = {
  33     [4] = HALIGN4,
  34     [8] = HALIGN8,
  35     [16] = HALIGN16,
  36 };
  37
  38 static const uint8_t anv_valign[] = {
  39     [4] = VALIGN4,
  40     [8] = VALIGN8,
  41     [16] = VALIGN16,
  42 };
  43
  44 static const uint8_t anv_surf_type_from_image_type[] = {
  45    [VK_IMAGE_TYPE_1D] = SURFTYPE_1D,
  46    [VK_IMAGE_TYPE_2D] = SURFTYPE_2D,
  47    [VK_IMAGE_TYPE_3D] = SURFTYPE_3D,
  48
  49 };
  50
  51 static const struct anv_image_view_info
  52 anv_image_view_info_table[] = {
  53    #define INFO(s, ...) { .surface_type = s, __VA_ARGS__ }
  54    [VK_IMAGE_VIEW_TYPE_1D]          = INFO(SURFTYPE_1D),
  55    [VK_IMAGE_VIEW_TYPE_2D]          = INFO(SURFTYPE_2D),
  56    [VK_IMAGE_VIEW_TYPE_3D]          = INFO(SURFTYPE_3D),
  57    [VK_IMAGE_VIEW_TYPE_CUBE]        = INFO(SURFTYPE_CUBE,                  .is_cube = 1),
  58    [VK_IMAGE_VIEW_TYPE_1D_ARRAY]    = INFO(SURFTYPE_1D,     .is_array = 1),
  59    [VK_IMAGE_VIEW_TYPE_2D_ARRAY]    = INFO(SURFTYPE_2D,     .is_array = 1),
  60    [VK_IMAGE_VIEW_TYPE_CUBE_ARRAY]  = INFO(SURFTYPE_CUBE,   .is_array = 1, .is_cube = 1),
  61    #undef INFO
  62 };
  63
  64 const struct anv_image_view_info *
  65 anv_image_view_info_for_vk_image_view_type(VkImageViewType type)
  66 {
  67    return &anv_image_view_info_table[type];
  68 }
  69
  70 static const struct anv_surf_type_limits {
  71    int32_t width;
  72    int32_t height;
  73    int32_t depth;
  74 } anv_surf_type_limits[] = {
  75    [SURFTYPE_1D]     = {16384,       1,   2048},
  76    [SURFTYPE_2D]     = {16384,   16384,   2048},
  77    [SURFTYPE_3D]     = {2048,     2048,   2048},
  78    [SURFTYPE_CUBE]   = {16384,   16384,    340},
  79    [SURFTYPE_BUFFER] = {128,     16384,     64},
  80    [SURFTYPE_STRBUF] = {128,     16384,     64},
  81 };
  82
  83 static const struct anv_tile_info {
  84    uint32_t width;
  85    uint32_t height;
  86
  87    /**
  88     * Alignment for RENDER_SURFACE_STATE.SurfaceBaseAddress.
  89     *
  90     * To simplify calculations, the alignments defined in the table are
  91     * sometimes larger than required.  For example, Skylake requires that X and
  92     * Y tiled buffers be aligned to 4K, but Broadwell permits smaller
  93     * alignment. We choose 4K to accomodate both chipsets.  The alignment of
  94     * a linear buffer depends on its element type and usage. Linear depth
  95     * buffers have the largest alignment, 64B, so we choose that for all linear
  96     * buffers.
  97     */
  98    uint32_t surface_alignment;
  99 } anv_tile_info_table[] = {
 100    [LINEAR] = {   1,  1,   64 },
 101    [XMAJOR] = { 512,  8, 4096 },
 102    [YMAJOR] = { 128, 32, 4096 },
 103    [WMAJOR] = { 128, 32, 4096 },
 104 };
 105
 106 /**
 107  * Return -1 on failure.
 108  */
 109 static int8_t
 110 anv_image_choose_tile_mode(const struct anv_image_create_info *anv_info)
 111 {
 112    if (anv_info->force_tile_mode)
 113       return anv_info->tile_mode;
 114
 115    /* The Sandybridge PRM says that the stencil buffer "is supported
 116     * only in Tile W memory".
 117     */
 118
 119    switch (anv_info->vk_info->tiling) {
 120    case VK_IMAGE_TILING_LINEAR:
 121       if (unlikely(anv_info->vk_info->format == VK_FORMAT_S8_UINT)) {
 122          return -1;
 123       } else {
 124          return LINEAR;
 125       }
 126    case VK_IMAGE_TILING_OPTIMAL:
 127       if (unlikely(anv_info->vk_info->format == VK_FORMAT_S8_UINT)) {
 128          return WMAJOR;
 129       } else {
 130          return YMAJOR;
 131       }
 132    default:
 133       assert(!"bad VKImageTiling");
 134       return LINEAR;
 135    }
 136 }
 137
 138
 139 /**
 140  * The \a format argument is required and overrides any format in
 141  * struct anv_image_create_info.
 142  */
 143 static VkResult
 144 anv_image_make_surface(const struct anv_image_create_info *create_info,
 145                        const struct anv_format *format,
 146                        uint64_t *inout_image_size,
 147                        uint32_t *inout_image_alignment,
 148                        struct anv_surface *out_surface)
 149 {
 150    /* See RENDER_SURFACE_STATE.SurfaceQPitch */
 151    static const uint16_t min_qpitch UNUSED = 0x4;
 152    static const uint16_t max_qpitch UNUSED = 0x1ffc;
 153
 154    const VkExtent3D *restrict extent = &create_info->vk_info->extent;
 155    const uint32_t levels = create_info->vk_info->mipLevels;
 156    const uint32_t array_size = create_info->vk_info->arraySize;
 157
 158    const int8_t tile_mode = anv_image_choose_tile_mode(create_info);
 159    if (tile_mode == -1)
 160       return vk_error(VK_ERROR_INVALID_IMAGE);
 161
 162    const struct anv_tile_info *tile_info =
 163        &anv_tile_info_table[tile_mode];
 164
 165    const uint32_t i = 4; /* FINISHME: Stop hardcoding subimage alignment */
 166    const uint32_t j = 4; /* FINISHME: Stop hardcoding subimage alignment */
 167
 168    uint16_t qpitch = min_qpitch;
 169    uint32_t mt_width = 0;
 170    uint32_t mt_height = 0;
 171
 172    switch (create_info->vk_info->imageType) {
 173    case VK_IMAGE_TYPE_1D:
 174       /* From the Broadwell PRM >> Memory Views >> Common Surface Formats >>
 175        * Surface Layout >> 1D Surfaces:
 176        *
 177        *    One-dimensional surfaces are identical to 2D surfaces with height of one.
 178        *
 179        * So fallthrough...
 180        */
 181    case VK_IMAGE_TYPE_2D: {
 182       const uint32_t w0 = align_u32(extent->width, i);
 183       const uint32_t h0 = align_u32(extent->height, j);
 184
 185       if (levels == 1 && array_size == 1) {
 186          qpitch = min_qpitch;
 187          mt_width = w0;
 188          mt_height = h0;
 189       } else {
 190          uint32_t w1 = align_u32(anv_minify(extent->width, 1), i);
 191          uint32_t h1 = align_u32(anv_minify(extent->height, 1), j);
 192          uint32_t w2 = align_u32(anv_minify(extent->width, 2), i);
 193
 194          /* The QPitch equation is found in the Broadwell PRM >> Volume 5: Memory
 195           * Views >> Common Surface Formats >> Surface Layout >> 2D Surfaces >>
 196           * Surface Arrays >> For All Surface Other Than Separate Stencil Buffer:
 197           */
 198          qpitch = h0 + h1 + 11 * j;
 199          mt_width = MAX(w0, w1 + w2);
 200          mt_height = array_size * qpitch;
 201       }
 202       break;
 203    }
 204    case VK_IMAGE_TYPE_3D:
 205       /* The layout of 3D surfaces is described by the Broadwell PRM >>
 206        * Volume 5: Memory Views >> Common Surface Formats >> Surface Layout >>
 207        * 3D Surfaces.
 208        */
 209       for (uint32_t l = 0; l < levels; ++l) {
 210          const uint32_t w_l = align_u32(anv_minify(extent->width, l), i);
 211          const uint32_t h_l = align_u32(anv_minify(extent->height, l), j);
 212          const uint32_t d_l = anv_minify(extent->depth, l);
 213
 214          const uint32_t max_layers_horiz = MIN(d_l, 1u << l);
 215          const uint32_t max_layers_vert = align_u32(d_l, 1u << l) / (1u << l);
 216
 217          mt_width = MAX(mt_width, w_l * max_layers_horiz);
 218          mt_height += h_l * max_layers_vert;
 219       }
 220       break;
 221    default:
 222       unreachable(!"bad VkImageType");
 223    }
 224
 225    assert(qpitch >= min_qpitch);
 226    if (qpitch > max_qpitch) {
 227       anv_loge("image qpitch > 0x%x\n", max_qpitch);
 228       return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY);
 229    }
 230
 231    /* From the Broadwell PRM, RENDER_SURFACE_STATE.SurfaceQpitch:
 232     *
 233     *   This field must be set an integer multiple of the Surface Vertical
 234     *   Alignment.
 235     */
 236    assert(anv_is_aligned(qpitch, j));
 237
 238    uint32_t stride = align_u32(mt_width * format->cpp, tile_info->width);
 239    if (create_info->stride > 0)
 240       stride = create_info->stride;
 241
 242    const uint32_t size = stride * align_u32(mt_height, tile_info->height);
 243    const uint32_t offset = align_u32(*inout_image_size,
 244                                      tile_info->surface_alignment);
 245
 246    *inout_image_size = offset + size;
 247    *inout_image_alignment = MAX(*inout_image_alignment,
 248                                 tile_info->surface_alignment);
 249
 250    *out_surface = (struct anv_surface) {
 251       .offset = offset,
 252       .stride = stride,
 253       .tile_mode = tile_mode,
 254       .qpitch = qpitch,
 255       .h_align = i,
 256       .v_align = j,
 257    };
 258
 259    return VK_SUCCESS;
 260 }
 261
 262 VkResult
 263 anv_image_create(VkDevice _device,
 264                  const struct anv_image_create_info *create_info,
 265                  VkImage *pImage)
 266 {
 267    ANV_FROM_HANDLE(anv_device, device, _device);
 268    const VkImageCreateInfo *pCreateInfo = create_info->vk_info;
 269    const VkExtent3D *restrict extent = &pCreateInfo->extent;
 270    struct anv_image *image = NULL;
 271    VkResult r;
 272
 273    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
 274
 275    anv_assert(pCreateInfo->mipLevels > 0);
 276    anv_assert(pCreateInfo->arraySize > 0);
 277    anv_assert(pCreateInfo->samples == 1);
 278    anv_assert(pCreateInfo->extent.width > 0);
 279    anv_assert(pCreateInfo->extent.height > 0);
 280    anv_assert(pCreateInfo->extent.depth > 0);
 281
 282    /* TODO(chadv): How should we validate inputs? */
 283    const uint8_t surf_type =
 284       anv_surf_type_from_image_type[pCreateInfo->imageType];
 285
 286    const struct anv_surf_type_limits *limits =
 287       &anv_surf_type_limits[surf_type];
 288
 289    if (extent->width > limits->width ||
 290        extent->height > limits->height ||
 291        extent->depth > limits->depth) {
 292       /* TODO(chadv): What is the correct error? */
 293       return vk_errorf(VK_ERROR_INVALID_MEMORY_SIZE, "image extent is too large");
 294    }
 295
 296    image = anv_device_alloc(device, sizeof(*image), 8,
 297                             VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
 298    if (!image)
 299       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 300
 301    memset(image, 0, sizeof(*image));
 302    image->type = pCreateInfo->imageType;
 303    image->extent = pCreateInfo->extent;
 304    image->format = anv_format_for_vk_format(pCreateInfo->format);
 305    image->levels = pCreateInfo->mipLevels;
 306    image->array_size = pCreateInfo->arraySize;
 307    image->surf_type = surf_type;
 308
 309    if (likely(anv_format_is_color(image->format))) {
 310       r = anv_image_make_surface(create_info, image->format,
 311                                  &image->size, &image->alignment,
 312                                  &image->color_surface);
 313       if (r != VK_SUCCESS)
 314          goto fail;
 315    } else {
 316       if (image->format->depth_format) {
 317          r = anv_image_make_surface(create_info, image->format,
 318                                     &image->size, &image->alignment,
 319                                     &image->depth_surface);
 320          if (r != VK_SUCCESS)
 321             goto fail;
 322       }
 323
 324       if (image->format->has_stencil) {
 325          r = anv_image_make_surface(create_info, anv_format_s8_uint,
 326                                     &image->size, &image->alignment,
 327                                     &image->stencil_surface);
 328          if (r != VK_SUCCESS)
 329             goto fail;
 330       }
 331    }
 332
 333    *pImage = anv_image_to_handle(image);
 334
 335    return VK_SUCCESS;
 336
 337 fail:
 338    if (image)
 339       anv_device_free(device, image);
 340
 341    return r;
 342 }
 343
 344 VkResult
 345 anv_CreateImage(VkDevice device,
 346                 const VkImageCreateInfo *pCreateInfo,
 347                 VkImage *pImage)
 348 {
 349    return anv_image_create(device,
 350       &(struct anv_image_create_info) {
 351          .vk_info = pCreateInfo,
 352       },
 353       pImage);
 354 }
 355
 356 VkResult
 357 anv_DestroyImage(VkDevice _device, VkImage _image)
 358 {
 359    ANV_FROM_HANDLE(anv_device, device, _device);
 360
 361    anv_device_free(device, anv_image_from_handle(_image));
 362
 363    return VK_SUCCESS;
 364 }
 365
 366 VkResult anv_GetImageSubresourceLayout(
 367     VkDevice                                    device,
 368     VkImage                                     image,
 369     const VkImageSubresource*                   pSubresource,
 370     VkSubresourceLayout*                        pLayout)
 371 {
 372    stub_return(VK_UNSUPPORTED);
 373 }
 374
 375 void
 376 anv_surface_view_fini(struct anv_device *device,
 377                       struct anv_surface_view *view)
 378 {
 379    anv_state_pool_free(&device->surface_state_pool, view->surface_state);
 380 }
 381
 382 VkResult
 383 anv_validate_CreateImageView(VkDevice _device,
 384                              const VkImageViewCreateInfo *pCreateInfo,
 385                              VkImageView *pView)
 386 {
 387    ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
 388    const VkImageSubresourceRange *subresource;
 389    const struct anv_image_view_info *view_info;
 390    const struct anv_format *view_format_info;
 391
 392    /* Validate structure type before dereferencing it. */
 393    assert(pCreateInfo);
 394    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
 395    subresource = &pCreateInfo->subresourceRange;
 396
 397    /* Validate viewType is in range before using it. */
 398    assert(pCreateInfo->viewType >= VK_IMAGE_VIEW_TYPE_BEGIN_RANGE);
 399    assert(pCreateInfo->viewType <= VK_IMAGE_VIEW_TYPE_END_RANGE);
 400    view_info = &anv_image_view_info_table[pCreateInfo->viewType];
 401
 402    /* Validate format is in range before using it. */
 403    assert(pCreateInfo->format >= VK_FORMAT_BEGIN_RANGE);
 404    assert(pCreateInfo->format <= VK_FORMAT_END_RANGE);
 405    view_format_info = anv_format_for_vk_format(pCreateInfo->format);
 406
 407    /* Validate channel swizzles. */
 408    assert(pCreateInfo->channels.r >= VK_CHANNEL_SWIZZLE_BEGIN_RANGE);
 409    assert(pCreateInfo->channels.r <= VK_CHANNEL_SWIZZLE_END_RANGE);
 410    assert(pCreateInfo->channels.g >= VK_CHANNEL_SWIZZLE_BEGIN_RANGE);
 411    assert(pCreateInfo->channels.g <= VK_CHANNEL_SWIZZLE_END_RANGE);
 412    assert(pCreateInfo->channels.b >= VK_CHANNEL_SWIZZLE_BEGIN_RANGE);
 413    assert(pCreateInfo->channels.b <= VK_CHANNEL_SWIZZLE_END_RANGE);
 414    assert(pCreateInfo->channels.a >= VK_CHANNEL_SWIZZLE_BEGIN_RANGE);
 415    assert(pCreateInfo->channels.a <= VK_CHANNEL_SWIZZLE_END_RANGE);
 416
 417    /* Validate subresource. */
 418    assert(subresource->aspectMask != 0);
 419    assert(subresource->mipLevels > 0);
 420    assert(subresource->arraySize > 0);
 421    assert(subresource->baseMipLevel < image->levels);
 422    assert(subresource->baseMipLevel + subresource->mipLevels <= image->levels);
 423    assert(subresource->baseArraySlice < image->array_size);
 424    assert(subresource->baseArraySlice + subresource->arraySize <= image->array_size);
 425    assert(pView);
 426
 427    if (view_info->is_cube) {
 428       assert(subresource->baseArraySlice % 6 == 0);
 429       assert(subresource->arraySize % 6 == 0);
 430    }
 431
 432    const VkImageAspectFlags ds_flags = VK_IMAGE_ASPECT_DEPTH_BIT
 433                                      | VK_IMAGE_ASPECT_STENCIL_BIT;
 434
 435    /* Validate format. */
 436    if (subresource->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
 437       assert(subresource->aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
 438       assert(!image->format->depth_format);
 439       assert(!image->format->has_stencil);
 440       assert(!view_format_info->depth_format);
 441       assert(!view_format_info->has_stencil);
 442       assert(view_format_info->cpp == image->format->cpp);
 443    } else if (subresource->aspectMask & ds_flags) {
 444       assert((subresource->aspectMask & ~ds_flags) == 0);
 445
 446       if (subresource->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
 447          assert(image->format->depth_format);
 448          assert(view_format_info->depth_format);
 449          assert(view_format_info->cpp == image->format->cpp);
 450       }
 451
 452       if (subresource->aspectMask & VK_IMAGE_ASPECT_STENCIL) {
 453          /* FINISHME: Is it legal to have an R8 view of S8? */
 454          assert(image->format->has_stencil);
 455          assert(view_format_info->has_stencil);
 456       }
 457    } else {
 458       assert(!"bad VkImageSubresourceRange::aspectFlags");
 459    }
 460
 461    return anv_CreateImageView(_device, pCreateInfo, pView);
 462 }
 463
 464 void
 465 anv_image_view_init(struct anv_image_view *iview,
 466                     struct anv_device *device,
 467                     const VkImageViewCreateInfo* pCreateInfo,
 468                     struct anv_cmd_buffer *cmd_buffer)
 469 {
 470    switch (device->info.gen) {
 471    case 7:
 472       gen7_image_view_init(iview, device, pCreateInfo, cmd_buffer);
 473       break;
 474    case 8:
 475       gen8_image_view_init(iview, device, pCreateInfo, cmd_buffer);
 476       break;
 477    default:
 478       unreachable("unsupported gen\n");
 479    }
 480 }
 481
 482 VkResult
 483 anv_CreateImageView(VkDevice _device,
 484                     const VkImageViewCreateInfo *pCreateInfo,
 485                     VkImageView *pView)
 486 {
 487    ANV_FROM_HANDLE(anv_device, device, _device);
 488    struct anv_image_view *view;
 489
 490    view = anv_device_alloc(device, sizeof(*view), 8,
 491                            VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
 492    if (view == NULL)
 493       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 494
 495    anv_image_view_init(view, device, pCreateInfo, NULL);
 496
 497    *pView = anv_image_view_to_handle(view);
 498
 499    return VK_SUCCESS;
 500 }
 501
 502 VkResult
 503 anv_DestroyImageView(VkDevice _device, VkImageView _iview)
 504 {
 505    ANV_FROM_HANDLE(anv_device, device, _device);
 506    ANV_FROM_HANDLE(anv_image_view, iview, _iview);
 507
 508    anv_surface_view_fini(device, &iview->view);
 509    anv_device_free(device, iview);
 510
 511    return VK_SUCCESS;
 512 }
 513
 514 static void
 515 anv_depth_stencil_view_init(struct anv_depth_stencil_view *view,
 516                             const VkAttachmentViewCreateInfo *pCreateInfo)
 517 {
 518    ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
 519
 520    view->base.attachment_type = ANV_ATTACHMENT_VIEW_TYPE_DEPTH_STENCIL;
 521
 522    /* XXX: We don't handle any of these */
 523    anv_assert(pCreateInfo->mipLevel == 0);
 524    anv_assert(pCreateInfo->baseArraySlice == 0);
 525    anv_assert(pCreateInfo->arraySize == 1);
 526
 527    view->image = image;
 528    view->format = anv_format_for_vk_format(pCreateInfo->format);
 529
 530    assert(anv_format_is_depth_or_stencil(image->format));
 531    assert(anv_format_is_depth_or_stencil(view->format));
 532 }
 533
 534 struct anv_surface *
 535 anv_image_get_surface_for_aspect_mask(struct anv_image *image, VkImageAspectFlags aspect_mask)
 536 {
 537    switch (aspect_mask) {
 538    case VK_IMAGE_ASPECT_COLOR_BIT:
 539       assert(anv_format_is_color(image->format));
 540       return &image->color_surface;
 541    case VK_IMAGE_ASPECT_DEPTH_BIT:
 542       assert(image->format->depth_format);
 543       return &image->depth_surface;
 544    case VK_IMAGE_ASPECT_STENCIL_BIT:
 545       assert(image->format->has_stencil);
 546       anv_finishme("stencil image views");
 547       return &image->stencil_surface;
 548    case VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT:
 549       /* FINISHME: The Vulkan spec (git a511ba2) requires support for combined
 550        * depth stencil formats. Specifically, it states:
 551        *
 552        *    At least one of ename:VK_FORMAT_D24_UNORM_S8_UINT or
 553        *    ename:VK_FORMAT_D32_SFLOAT_S8_UINT must be supported.
 554        */
 555       anv_finishme("combined depthstencil aspect");
 556       assert(image->format->depth_format);
 557       return &image->depth_surface;
 558     default:
 559        unreachable("image does not have aspect");
 560        return NULL;
 561    }
 562 }
 563
 564 /** The attachment may be a color view into a non-color image.  */
 565 struct anv_surface *
 566 anv_image_get_surface_for_color_attachment(struct anv_image *image)
 567 {
 568    if (anv_format_is_color(image->format)) {
 569       return &image->color_surface;
 570    } else if (image->format->depth_format) {
 571       return &image->depth_surface;
 572    } else if (image->format->has_stencil) {
 573       return &image->stencil_surface;
 574    } else {
 575       unreachable("image has bad format");
 576       return NULL;
 577    }
 578 }
 579
 580 void
 581 anv_color_attachment_view_init(struct anv_color_attachment_view *aview,
 582                                struct anv_device *device,
 583                                const VkAttachmentViewCreateInfo* pCreateInfo,
 584                                struct anv_cmd_buffer *cmd_buffer)
 585 {
 586    switch (device->info.gen) {
 587    case 7:
 588       gen7_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer);
 589       break;
 590    case 8:
 591       gen8_color_attachment_view_init(aview, device, pCreateInfo, cmd_buffer);
 592       break;
 593    default:
 594       unreachable("unsupported gen\n");
 595    }
 596 }
 597
 598 VkResult
 599 anv_CreateAttachmentView(VkDevice _device,
 600                          const VkAttachmentViewCreateInfo *pCreateInfo,
 601                          VkAttachmentView *pView)
 602 {
 603    ANV_FROM_HANDLE(anv_device, device, _device);
 604
 605    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO);
 606
 607    const struct anv_format *format =
 608       anv_format_for_vk_format(pCreateInfo->format);
 609
 610    if (anv_format_is_depth_or_stencil(format)) {
 611       struct anv_depth_stencil_view *view =
 612          anv_device_alloc(device, sizeof(*view), 8,
 613                           VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
 614       if (view == NULL)
 615          return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 616
 617       anv_depth_stencil_view_init(view, pCreateInfo);
 618
 619       *pView = anv_attachment_view_to_handle(&view->base);
 620    } else {
 621       struct anv_color_attachment_view *view =
 622          anv_device_alloc(device, sizeof(*view), 8,
 623                           VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
 624       if (view == NULL)
 625          return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 626
 627       anv_color_attachment_view_init(view, device, pCreateInfo, NULL);
 628
 629       *pView = anv_attachment_view_to_handle(&view->base);
 630    }
 631
 632    return VK_SUCCESS;
 633 }
 634
 635 VkResult
 636 anv_DestroyAttachmentView(VkDevice _device, VkAttachmentView _view)
 637 {
 638    ANV_FROM_HANDLE(anv_device, device, _device);
 639    ANV_FROM_HANDLE(anv_attachment_view, view, _view);
 640
 641    if (view->attachment_type == ANV_ATTACHMENT_VIEW_TYPE_COLOR) {
 642       struct anv_color_attachment_view *aview =
 643          (struct anv_color_attachment_view *)view;
 644
 645       anv_surface_view_fini(device, &aview->view);
 646    }
 647
 648    anv_device_free(device, view);
 649
 650    return VK_SUCCESS;
 651 }