const struct anv_image_view *iview =
fb->attachments[subpass->color_attachments[a]];
- bt_map[a] = iview->surface_state.offset + state_offset;
- add_surface_state_reloc(cmd_buffer, iview->surface_state,
+ bt_map[a] = iview->color_rt_surface_state.offset + state_offset;
+ add_surface_state_reloc(cmd_buffer, iview->color_rt_surface_state,
iview->bo, iview->offset);
}
bo_offset = desc->buffer_view->offset;
break;
case ANV_DESCRIPTOR_TYPE_IMAGE_VIEW:
- surface_state = &desc->image_view->surface_state;
+ surface_state = &desc->image_view->nonrt_surface_state;
bo = desc->image_view->bo;
bo_offset = desc->image_view->offset;
break;
[VK_IMAGE_TYPE_1D] = SURFTYPE_1D,
[VK_IMAGE_TYPE_2D] = SURFTYPE_2D,
[VK_IMAGE_TYPE_3D] = SURFTYPE_3D,
-
};
static const struct anv_image_view_info
return VK_SUCCESS;
}
+static VkImageUsageFlags
+anv_image_get_full_usage(const VkImageCreateInfo *info)
+{
+ VkImageUsageFlags usage = info->usage;
+
+ if (usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) {
+ /* Meta will transfer from the image by binding it as a texture. */
+ usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+ }
+
+ if (usage & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) {
+ /* Meta will transfer to the image by binding it as a color attachment,
+ * even if the image format is not a color format.
+ */
+ usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ }
+
+ return usage;
+}
+
VkResult
anv_image_create(VkDevice _device,
const struct anv_image_create_info *create_info,
image->format = anv_format_for_vk_format(pCreateInfo->format);
image->levels = pCreateInfo->mipLevels;
image->array_size = pCreateInfo->arraySize;
- image->usage = pCreateInfo->usage;
- image->surf_type = surf_type;
+ image->usage = anv_image_get_full_usage(pCreateInfo);
+ image->surface_type = surf_type;
- if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT) {
- /* Meta will transfer from the image by binding it as a texture. */
- image->usage |= VK_IMAGE_USAGE_SAMPLED_BIT;
+ if (image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
+ VK_IMAGE_USAGE_STORAGE_BIT)) {
+ image->needs_nonrt_surface_state = true;
}
- if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT) {
- /* Meta will transfer to the image by binding it as a color attachment,
- * even if the image format is not a color format.
- */
- image->usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+ if (image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
+ image->needs_color_rt_surface_state = true;
}
if (likely(anv_format_is_color(image->format))) {
struct anv_cmd_buffer *cmd_buffer)
{
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
+ const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
+ assert(range->arraySize > 0);
+ assert(range->baseMipLevel < image->levels);
assert(image->usage & (VK_IMAGE_USAGE_SAMPLED_BIT |
- VK_IMAGE_USAGE_STORAGE_BIT));
+ VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+ VK_IMAGE_USAGE_DEPTH_STENCIL_BIT));
+
+ switch (image->type) {
+ default:
+ unreachable("bad VkImageType");
+ case VK_IMAGE_TYPE_1D:
+ case VK_IMAGE_TYPE_2D:
+ assert(range->baseArrayLayer + range->arraySize - 1 <= image->array_size);
+ break;
+ case VK_IMAGE_TYPE_3D:
+ assert(range->baseArrayLayer + range->arraySize - 1
+ <= anv_minify(image->extent.depth, range->baseMipLevel));
+ break;
+ }
switch (device->info.gen) {
case 7:
return VK_SUCCESS;
}
-void
-anv_DestroyImageView(VkDevice _device, VkImageView _iview)
+static void
+anv_image_view_destroy(struct anv_device *device,
+ struct anv_image_view *iview)
{
- ANV_FROM_HANDLE(anv_device, device, _device);
- ANV_FROM_HANDLE(anv_image_view, iview, _iview);
+ if (iview->image->needs_color_rt_surface_state) {
+ anv_state_pool_free(&device->surface_state_pool,
+ iview->color_rt_surface_state);
+ }
+
+ if (iview->image->needs_nonrt_surface_state) {
+ anv_state_pool_free(&device->surface_state_pool,
+ iview->nonrt_surface_state);
+ }
- anv_state_pool_free(&device->surface_state_pool, iview->surface_state);
anv_device_free(device, iview);
}
-static void
-anv_depth_stencil_view_init(struct anv_image_view *iview,
- const VkAttachmentViewCreateInfo *pCreateInfo)
+void
+anv_DestroyImageView(VkDevice _device, VkImageView _iview)
{
- ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
-
- assert(image->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT);
-
- iview->image = image;
- iview->format = anv_format_for_vk_format(pCreateInfo->format);
+ ANV_FROM_HANDLE(anv_device, device, _device);
+ ANV_FROM_HANDLE(anv_image_view, iview, _iview);
- assert(anv_format_is_depth_or_stencil(image->format));
- assert(anv_format_is_depth_or_stencil(iview->format));
+ anv_image_view_destroy(device, iview);
}
struct anv_surface *
{
switch (aspect_mask) {
case VK_IMAGE_ASPECT_COLOR_BIT:
- assert(anv_format_is_color(image->format));
- return &image->color_surface;
+ /* Dragons will eat you.
+ *
+ * Meta attaches all destination surfaces as color render targets. Guess
+ * what surface the Meta Dragons really want.
+ */
+ if (image->format->depth_format && image->format->has_stencil) {
+ anv_finishme("combined depth stencil formats");
+ return &image->depth_surface;
+ } else if (image->format->depth_format) {
+ return &image->depth_surface;
+ } else if (image->format->has_stencil) {
+ return &image->stencil_surface;
+ } else {
+ return &image->color_surface;
+ }
+ break;
case VK_IMAGE_ASPECT_DEPTH_BIT:
assert(image->format->depth_format);
return &image->depth_surface;
}
}
-/** The attachment may be a color view into a non-color image. */
-struct anv_surface *
-anv_image_get_surface_for_color_attachment(struct anv_image *image)
-{
- if (anv_format_is_color(image->format)) {
- return &image->color_surface;
- } else if (image->format->depth_format) {
- return &image->depth_surface;
- } else if (image->format->has_stencil) {
- return &image->stencil_surface;
- } else {
- unreachable("image has bad format");
- return NULL;
- }
-}
-
-void
-anv_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer)
-{
- ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
-
- assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
-
- switch (device->info.gen) {
- case 7:
- gen7_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer);
- break;
- case 8:
- gen8_color_attachment_view_init(iview, device, pCreateInfo, cmd_buffer);
- break;
- default:
- unreachable("unsupported gen\n");
- }
-}
-
VkResult
anv_CreateAttachmentView(VkDevice _device,
- const VkAttachmentViewCreateInfo *pCreateInfo,
+ const VkAttachmentViewCreateInfo *info,
VkAttachmentView *pView)
{
ANV_FROM_HANDLE(anv_device, device, _device);
struct anv_image_view *iview;
- assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO);
+ assert(info->sType == VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO);
iview = anv_device_alloc(device, sizeof(*iview), 8,
VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
if (iview == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
- const struct anv_format *format =
- anv_format_for_vk_format(pCreateInfo->format);
-
- if (anv_format_is_depth_or_stencil(format)) {
- anv_depth_stencil_view_init(iview, pCreateInfo);
- } else {
- anv_color_attachment_view_init(iview, device, pCreateInfo, NULL);
- }
+ const struct anv_format *format = anv_format_for_vk_format(info->format);
+
+ VkImageAspectFlags aspect_mask = 0;
+ if (format->depth_format)
+ aspect_mask |= VK_IMAGE_ASPECT_DEPTH_BIT;
+ if (format->has_stencil)
+ aspect_mask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+ if (!aspect_mask)
+ aspect_mask |= VK_IMAGE_ASPECT_COLOR_BIT;
+
+ anv_image_view_init(iview, device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+ .image = info->image,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
+ .format = info->format,
+ .channels = {
+ .r = VK_CHANNEL_SWIZZLE_R,
+ .g = VK_CHANNEL_SWIZZLE_G,
+ .b = VK_CHANNEL_SWIZZLE_B,
+ .a = VK_CHANNEL_SWIZZLE_A,
+ },
+ .subresourceRange = {
+ .aspectMask = aspect_mask,
+ .baseMipLevel = info->mipLevel,
+ .mipLevels = 1,
+ .baseArrayLayer = info->baseArraySlice,
+ .arraySize = info->arraySize,
+ },
+ },
+ NULL);
pView->handle = anv_image_view_to_handle(iview).handle;
VkImageView _iview = { .handle = _aview.handle };
ANV_FROM_HANDLE(anv_image_view, iview, _iview);
- /* Depth and stencil render targets have no RENDER_SURFACE_STATE. Instead,
- * they use 3DSTATE_DEPTH_BUFFER and 3DSTATE_STENCIL_BUFFER.
- */
- if (!anv_format_is_depth_or_stencil(iview->format)) {
- anv_state_pool_free(&device->surface_state_pool, iview->surface_state);
- }
-
- anv_device_free(device, iview);
+ anv_image_view_destroy(device, iview);
}
cmd_buffer);
struct anv_image_view dest_iview;
- anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&dest_iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = dest_image,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = copy_format,
- .mipLevel = 0,
- .baseArraySlice = 0,
- .arraySize = 1,
+ .channels = {
+ .r = VK_CHANNEL_SWIZZLE_R,
+ .g = VK_CHANNEL_SWIZZLE_G,
+ .b = VK_CHANNEL_SWIZZLE_B,
+ .a = VK_CHANNEL_SWIZZLE_A,
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = 0,
+ .mipLevels = 1,
+ .baseArrayLayer = 0,
+ .arraySize = 1,
+ },
},
cmd_buffer);
anv_finishme("FINISHME: copy multiple depth layers");
struct anv_image_view dest_iview;
- anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&dest_iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = destImage,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = dest_image->format->vk_format,
- .mipLevel = pRegions[r].destSubresource.mipLevel,
- .baseArraySlice = dest_array_slice,
- .arraySize = 1,
+ .channels = {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = pRegions[r].destSubresource.mipLevel,
+ .mipLevels = 1,
+ .baseArrayLayer = dest_array_slice,
+ .arraySize = 1
+ },
},
cmd_buffer);
anv_finishme("FINISHME: copy multiple depth layers");
struct anv_image_view dest_iview;
- anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&dest_iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = destImage,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = dest_image->format->vk_format,
- .mipLevel = pRegions[r].destSubresource.mipLevel,
- .baseArraySlice = dest_array_slice,
- .arraySize = 1,
+ .channels = {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = pRegions[r].destSubresource.mipLevel,
+ .mipLevels = 1,
+ .baseArrayLayer = dest_array_slice,
+ .arraySize = 1
+ },
},
cmd_buffer);
anv_finishme("FINISHME: copy multiple depth layers");
struct anv_image_view dest_iview;
- anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&dest_iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = anv_image_to_handle(dest_image),
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = proxy_format,
- .mipLevel = pRegions[r].imageSubresource.mipLevel,
- .baseArraySlice = dest_array_slice,
- .arraySize = 1,
+ .channels = {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = pRegions[r].imageSubresource.mipLevel,
+ .mipLevels = 1,
+ .baseArrayLayer = dest_array_slice,
+ .arraySize = 1
+ },
},
cmd_buffer);
dest_format, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, &pRegions[r]);
struct anv_image_view dest_iview;
- anv_color_attachment_view_init(&dest_iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&dest_iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = destImage,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = dest_format,
- .mipLevel = 0,
- .baseArraySlice = 0,
- .arraySize = 1,
+ .channels = {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = 0,
+ .mipLevels = 1,
+ .baseArrayLayer = 0,
+ .arraySize = 1
+ },
},
cmd_buffer);
for (uint32_t l = 0; l < pRanges[r].mipLevels; l++) {
for (uint32_t s = 0; s < pRanges[r].arraySize; s++) {
struct anv_image_view iview;
- anv_color_attachment_view_init(&iview, cmd_buffer->device,
- &(VkAttachmentViewCreateInfo) {
- .sType = VK_STRUCTURE_TYPE_ATTACHMENT_VIEW_CREATE_INFO,
+ anv_image_view_init(&iview, cmd_buffer->device,
+ &(VkImageViewCreateInfo) {
+ .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = _image,
+ .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = image->format->vk_format,
- .mipLevel = pRanges[r].baseMipLevel + l,
- .baseArraySlice = pRanges[r].baseArrayLayer + s,
- .arraySize = 1,
+ .channels = {
+ VK_CHANNEL_SWIZZLE_R,
+ VK_CHANNEL_SWIZZLE_G,
+ VK_CHANNEL_SWIZZLE_B,
+ VK_CHANNEL_SWIZZLE_A
+ },
+ .subresourceRange = {
+ .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+ .baseMipLevel = pRanges[r].baseMipLevel + l,
+ .mipLevels = 1,
+ .baseArrayLayer = pRanges[r].baseArrayLayer + s,
+ .arraySize = 1
+ },
},
cmd_buffer);
VkExtent3D extent;
uint32_t levels;
uint32_t array_size;
- VkImageUsageFlags usage; /**< VkImageCreateInfo::usage */
+ VkImageUsageFlags usage; /**< Superset of VkImageCreateInfo::usage. */
VkDeviceSize size;
uint32_t alignment;
struct anv_bo *bo;
VkDeviceSize offset;
- /** RENDER_SURFACE_STATE.SurfaceType */
- uint8_t surf_type;
+ uint8_t surface_type; /**< RENDER_SURFACE_STATE.SurfaceType */
+
+ bool needs_nonrt_surface_state:1;
+ bool needs_color_rt_surface_state:1;
/**
* Image subsurfaces
struct anv_image_view {
const struct anv_image *image; /**< VkImageViewCreateInfo::image */
const struct anv_format *format; /**< VkImageViewCreateInfo::format */
- struct anv_state surface_state; /**< RENDER_SURFACE_STATE */
struct anv_bo *bo;
uint32_t offset; /**< Offset into bo. */
VkExtent3D extent; /**< Extent of VkImageViewCreateInfo::baseMipLevel. */
+
+ /** RENDER_SURFACE_STATE when using image as a color render target. */
+ struct anv_state color_rt_surface_state;
+
+ /** RENDER_SURFACE_STATE when using image as a non render target. */
+ struct anv_state nonrt_surface_state;
};
struct anv_image_create_info {
anv_image_get_surface_for_aspect_mask(struct anv_image *image,
VkImageAspectFlags aspect_mask);
-struct anv_surface *
-anv_image_get_surface_for_color_attachment(struct anv_image *image);
-
void anv_image_view_init(struct anv_image_view *view,
struct anv_device *device,
const VkImageViewCreateInfo* pCreateInfo,
const VkImageViewCreateInfo* pCreateInfo,
struct anv_cmd_buffer *cmd_buffer);
-void anv_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer);
-
-void gen7_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer);
-
-void gen8_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer);
-
VkResult anv_buffer_view_create(struct anv_device *device,
const VkBufferViewCreateInfo *pCreateInfo,
struct anv_buffer_view **bview_out);
[VK_COMPARE_OP_ALWAYS] = PREFILTEROPALWAYS,
};
+static struct anv_state
+gen7_alloc_surface_state(struct anv_device *device,
+ struct anv_cmd_buffer *cmd_buffer)
+{
+ if (cmd_buffer) {
+ return anv_state_stream_alloc(&cmd_buffer->surface_state_stream,
+ 64, 64);
+ } else {
+ return anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
+ }
+}
+
VkResult gen7_CreateSampler(
VkDevice _device,
const VkSamplerCreateInfo* pCreateInfo,
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
+
struct anv_surface *surface =
anv_image_get_surface_for_aspect_mask(image, range->aspectMask);
const struct anv_format *format =
anv_format_for_vk_format(pCreateInfo->format);
- const struct anv_image_view_info view_type_info =
- anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType);
-
if (pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D)
anv_finishme("non-2D image views");
+ iview->image = image;
iview->bo = image->bo;
iview->offset = image->offset + surface->offset;
iview->format = anv_format_for_vk_format(pCreateInfo->format);
}
struct GEN7_RENDER_SURFACE_STATE surface_state = {
- .SurfaceType = view_type_info.surface_type,
+ .SurfaceType = image->surface_type,
.SurfaceArray = image->array_size > 1,
.SurfaceFormat = format->surface_format,
.SurfaceVerticalAlignment = anv_valign[surface->v_align],
.VerticalLineStride = 0,
.VerticalLineStrideOffset = 0,
- .RenderCacheReadWriteMode = false,
+
+ .RenderCacheReadWriteMode = 0, /* TEMPLATE */
.Height = image->extent.height - 1,
.Width = image->extent.width - 1,
.SurfaceObjectControlState = GEN7_MOCS,
- /* For render target surfaces, the hardware interprets field MIPCount/LOD as
- * LOD. The Broadwell PRM says:
- *
- * MIPCountLOD defines the LOD that will be rendered into.
- * SurfaceMinLOD is ignored.
- */
- .MIPCountLOD = range->mipLevels - 1,
- .SurfaceMinLOD = range->baseMipLevel,
+ .MIPCountLOD = 0, /* TEMPLATE */
+ .SurfaceMinLOD = 0, /* TEMPLATE */
.MCSEnable = false,
.RedClearColor = 0,
.SurfaceBaseAddress = { NULL, iview->offset },
};
- if (cmd_buffer) {
- iview->surface_state =
- anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64);
- } else {
- iview->surface_state =
- anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
- }
-
- GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map,
- &surface_state);
-}
-
-void
-gen7_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer)
-{
- ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
- struct anv_surface *surface =
- anv_image_get_surface_for_color_attachment(image);
+ if (image->needs_nonrt_surface_state) {
+ iview->nonrt_surface_state =
+ gen7_alloc_surface_state(device, cmd_buffer);
- assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
- anv_assert(pCreateInfo->arraySize > 0);
- anv_assert(pCreateInfo->mipLevel < image->levels);
- anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size);
+ surface_state.RenderCacheReadWriteMode = false;
- iview->bo = image->bo;
- iview->offset = image->offset + surface->offset;
- iview->format = anv_format_for_vk_format(pCreateInfo->format);
-
- iview->extent = (VkExtent3D) {
- .width = anv_minify(image->extent.width, pCreateInfo->mipLevel),
- .height = anv_minify(image->extent.height, pCreateInfo->mipLevel),
- .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel),
- };
-
- uint32_t depth = 1;
- if (pCreateInfo->arraySize > 1) {
- depth = pCreateInfo->arraySize;
- } else if (image->extent.depth > 1) {
- depth = image->extent.depth;
- }
-
- if (cmd_buffer) {
- iview->surface_state =
- anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64);
- } else {
- iview->surface_state =
- anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
- }
-
- struct GEN7_RENDER_SURFACE_STATE surface_state = {
- .SurfaceType = SURFTYPE_2D,
- .SurfaceArray = image->array_size > 1,
- .SurfaceFormat = iview->format->surface_format,
- .SurfaceVerticalAlignment = anv_valign[surface->v_align],
- .SurfaceHorizontalAlignment = anv_halign[surface->h_align],
-
- /* From bspec (DevSNB, DevIVB): "Set Tile Walk to TILEWALK_XMAJOR if
- * Tiled Surface is False."
+ /* For non render target surfaces, the hardware interprets field
+ * MIPCount/LOD as MIPCount. The range of levels accessible by the
+ * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD].
*/
- .TiledSurface = surface->tile_mode > LINEAR,
- .TileWalk = surface->tile_mode == YMAJOR ? TILEWALK_YMAJOR : TILEWALK_XMAJOR,
+ surface_state.SurfaceMinLOD = range->baseMipLevel;
+ surface_state.MIPCountLOD = range->mipLevels - 1;
- .VerticalLineStride = 0,
- .VerticalLineStrideOffset = 0,
- .RenderCacheReadWriteMode = WriteOnlyCache,
+ GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->nonrt_surface_state.map,
+ &surface_state);
+ }
- .Height = image->extent.height - 1,
- .Width = image->extent.width - 1,
- .Depth = depth - 1,
- .SurfacePitch = surface->stride - 1,
- .MinimumArrayElement = pCreateInfo->baseArraySlice,
- .NumberofMultisamples = MULTISAMPLECOUNT_1,
- .XOffset = 0,
- .YOffset = 0,
+ if (image->needs_color_rt_surface_state) {
+ iview->color_rt_surface_state =
+ gen7_alloc_surface_state(device, cmd_buffer);
- .SurfaceObjectControlState = GEN7_MOCS,
+ surface_state.RenderCacheReadWriteMode = WriteOnlyCache;
/* For render target surfaces, the hardware interprets field MIPCount/LOD as
* LOD. The Broadwell PRM says:
* MIPCountLOD defines the LOD that will be rendered into.
* SurfaceMinLOD is ignored.
*/
- .SurfaceMinLOD = 0,
- .MIPCountLOD = pCreateInfo->mipLevel,
-
- .MCSEnable = false,
- .RedClearColor = 0,
- .GreenClearColor = 0,
- .BlueClearColor = 0,
- .AlphaClearColor = 0,
- .ResourceMinLOD = 0.0,
- .SurfaceBaseAddress = { NULL, iview->offset },
-
- };
+ surface_state.MIPCountLOD = range->baseMipLevel;
+ surface_state.SurfaceMinLOD = 0;
- GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map,
- &surface_state);
+ GEN7_RENDER_SURFACE_STATE_pack(NULL, iview->color_rt_surface_state.map,
+ &surface_state);
+ }
}
[16] = VALIGN16,
};
+static struct anv_state
+gen8_alloc_surface_state(struct anv_device *device,
+ struct anv_cmd_buffer *cmd_buffer)
+{
+ if (cmd_buffer) {
+ return anv_state_stream_alloc(&cmd_buffer->surface_state_stream,
+ 64, 64);
+ } else {
+ return anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
+ }
+}
+
void
gen8_image_view_init(struct anv_image_view *iview,
struct anv_device *device,
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
+
struct anv_surface *surface =
anv_image_get_surface_for_aspect_mask(image, range->aspectMask);
const struct anv_format *format_info =
anv_format_for_vk_format(pCreateInfo->format);
- const struct anv_image_view_info view_type_info =
- anv_image_view_info_for_vk_image_view_type(pCreateInfo->viewType);
-
+ iview->image = image;
iview->bo = image->bo;
iview->offset = image->offset + surface->offset;
iview->format = format_info;
};
struct GEN8_RENDER_SURFACE_STATE surface_state = {
- .SurfaceType = view_type_info.surface_type,
+ .SurfaceType = image->surface_type,
.SurfaceArray = image->array_size > 1,
.SurfaceFormat = format_info->surface_format,
.SurfaceVerticalAlignment = anv_valign[surface->v_align],
.XOffset = 0,
.YOffset = 0,
- /* For sampler surfaces, the hardware interprets field MIPCount/LOD as
- * MIPCount. The range of levels accessible by the sampler engine is
- * [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD].
- */
- .MIPCountLOD = range->mipLevels - 1,
- .SurfaceMinLOD = range->baseMipLevel,
+ .MIPCountLOD = 0, /* TEMPLATE */
+ .SurfaceMinLOD = 0, /* TEMPLATE */
.AuxiliarySurfaceMode = AUX_NONE,
.RedClearColor = 0,
.SurfaceBaseAddress = { NULL, iview->offset },
};
- if (cmd_buffer) {
- iview->surface_state =
- anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64);
- } else {
- iview->surface_state =
- anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
- }
-
- GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map,
- &surface_state);
-}
-
-void
-gen8_color_attachment_view_init(struct anv_image_view *iview,
- struct anv_device *device,
- const VkAttachmentViewCreateInfo* pCreateInfo,
- struct anv_cmd_buffer *cmd_buffer)
-{
- ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
- struct anv_surface *surface =
- anv_image_get_surface_for_color_attachment(image);
- const struct anv_format *format_info =
- anv_format_for_vk_format(pCreateInfo->format);
-
- uint32_t depth = 1; /* RENDER_SURFACE_STATE::Depth */
- uint32_t rt_view_extent = 1; /* RENDER_SURFACE_STATE::RenderTargetViewExtent */
-
- assert(image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
- anv_assert(pCreateInfo->arraySize > 0);
- anv_assert(pCreateInfo->mipLevel < image->levels);
- anv_assert(pCreateInfo->baseArraySlice + pCreateInfo->arraySize <= image->array_size);
-
- iview->bo = image->bo;
- iview->offset = image->offset + surface->offset;
- iview->format = anv_format_for_vk_format(pCreateInfo->format);
-
- iview->extent = (VkExtent3D) {
- .width = anv_minify(image->extent.width, pCreateInfo->mipLevel),
- .height = anv_minify(image->extent.height, pCreateInfo->mipLevel),
- .depth = anv_minify(image->extent.depth, pCreateInfo->mipLevel),
- };
+ if (image->needs_nonrt_surface_state) {
+ iview->nonrt_surface_state =
+ gen8_alloc_surface_state(device, cmd_buffer);
- switch (image->type) {
- case VK_IMAGE_TYPE_1D:
- case VK_IMAGE_TYPE_2D:
- /* From the Broadwell PRM >> RENDER_SURFACE_STATE::Depth:
- *
- * For SURFTYPE_1D, 2D, and CUBE: The range of this field is reduced
- * by one for each increase from zero of Minimum Array Element. For
- * example, if Minimum Array Element is set to 1024 on a 2D surface,
- * the range of this field is reduced to [0,1023].
- */
- depth = pCreateInfo->arraySize;
-
- /* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent:
- *
- * For Render Target and Typed Dataport 1D and 2D Surfaces:
- * This field must be set to the same value as the Depth field.
+ /* For non render target surfaces, the hardware interprets field
+ * MIPCount/LOD as MIPCount. The range of levels accessible by the
+ * sampler engine is [SurfaceMinLOD, SurfaceMinLOD + MIPCountLOD].
*/
- rt_view_extent = depth;
- break;
- case VK_IMAGE_TYPE_3D:
- /* From the Broadwell PRM >> RENDER_SURFACE_STATE::Depth:
- *
- * If the volume texture is MIP-mapped, this field specifies the
- * depth of the base MIP level.
- */
- depth = image->extent.depth;
+ surface_state.SurfaceMinLOD = range->baseMipLevel;
+ surface_state.MIPCountLOD = range->mipLevels - 1;
- /* From the Broadwell PRM >> RENDER_SURFACE_STATE::RenderTargetViewExtent:
- *
- * For Render Target and Typed Dataport 3D Surfaces: This field
- * indicates the extent of the accessible 'R' coordinates minus 1 on
- * the LOD currently being rendered to.
- */
- rt_view_extent = iview->extent.depth;
- break;
- default:
- unreachable(!"bad VkImageType");
- }
-
- if (cmd_buffer) {
- iview->surface_state =
- anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 64, 64);
- } else {
- iview->surface_state =
- anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
+ GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->nonrt_surface_state.map,
+ &surface_state);
}
- struct GEN8_RENDER_SURFACE_STATE surface_state = {
- .SurfaceType = image->type,
- .SurfaceArray = image->array_size > 1,
- .SurfaceFormat = format_info->surface_format,
- .SurfaceVerticalAlignment = anv_valign[surface->v_align],
- .SurfaceHorizontalAlignment = anv_halign[surface->h_align],
- .TileMode = surface->tile_mode,
- .VerticalLineStride = 0,
- .VerticalLineStrideOffset = 0,
- .SamplerL2BypassModeDisable = true,
- .RenderCacheReadWriteMode = WriteOnlyCache,
- .MemoryObjectControlState = GEN8_MOCS,
-
- /* The driver sets BaseMipLevel in SAMPLER_STATE, not here in
- * RENDER_SURFACE_STATE. The Broadwell PRM says "it is illegal to have
- * both Base Mip Level fields nonzero".
- */
- .BaseMipLevel = 0.0,
-
- .SurfaceQPitch = surface->qpitch >> 2,
- .Height = image->extent.height - 1,
- .Width = image->extent.width - 1,
- .Depth = depth - 1,
- .SurfacePitch = surface->stride - 1,
- .RenderTargetViewExtent = rt_view_extent - 1,
- .MinimumArrayElement = pCreateInfo->baseArraySlice,
- .NumberofMultisamples = MULTISAMPLECOUNT_1,
- .XOffset = 0,
- .YOffset = 0,
+ if (image->needs_color_rt_surface_state) {
+ iview->color_rt_surface_state =
+ gen8_alloc_surface_state(device, cmd_buffer);
- /* For render target surfaces, the hardware interprets field MIPCount/LOD as
- * LOD. The Broadwell PRM says:
+ /* For render target surfaces, the hardware interprets field
+ * MIPCount/LOD as LOD. The Broadwell PRM says:
*
* MIPCountLOD defines the LOD that will be rendered into.
* SurfaceMinLOD is ignored.
*/
- .SurfaceMinLOD = 0,
- .MIPCountLOD = pCreateInfo->mipLevel,
-
- .AuxiliarySurfaceMode = AUX_NONE,
- .RedClearColor = 0,
- .GreenClearColor = 0,
- .BlueClearColor = 0,
- .AlphaClearColor = 0,
- .ShaderChannelSelectRed = SCS_RED,
- .ShaderChannelSelectGreen = SCS_GREEN,
- .ShaderChannelSelectBlue = SCS_BLUE,
- .ShaderChannelSelectAlpha = SCS_ALPHA,
- .ResourceMinLOD = 0.0,
- .SurfaceBaseAddress = { NULL, iview->offset },
- };
+ surface_state.MIPCountLOD = range->baseMipLevel;
+ surface_state.SurfaceMinLOD = 0;
- GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->surface_state.map,
- &surface_state);
+ GEN8_RENDER_SURFACE_STATE_pack(NULL, iview->color_rt_surface_state.map,
+ &surface_state);
+ }
}
VkResult gen8_CreateSampler(
projects / mesa.git / commitdiff