OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

anv: Use ISL to fill out surface states

Browse Source
This commit is contained in:
Jason Ekstrand
2016-02-20 11:45:50 -08:00
parent 4a9b805ce5
commit ded57c3cca
1 changed files with 79 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
src/intel/vulkan/anv_image.c
View File

@@ -427,37 +427,6 @@ anv_validate_CreateImageView(VkDevice _device,
return anv_CreateImageView(_device, pCreateInfo, pAllocator, pView); return anv_CreateImageView(_device, pCreateInfo, pAllocator, pView);
} }
void
anv_fill_image_surface_state(struct anv_device *device, struct anv_state state,
struct anv_image_view *iview,
const VkImageViewCreateInfo *pCreateInfo,
VkImageUsageFlagBits usage)
{
switch (device->info.gen) {
case 7:
if (device->info.is_haswell)
gen75_fill_image_surface_state(device, state.map, iview,
pCreateInfo, usage);
else
gen7_fill_image_surface_state(device, state.map, iview,
pCreateInfo, usage);
break;
case 8:
gen8_fill_image_surface_state(device, state.map, iview,
pCreateInfo, usage);
break;
case 9:
gen9_fill_image_surface_state(device, state.map, iview,
pCreateInfo, usage);
break;
default:
unreachable("unsupported gen\n");
}
if (!device->info.has_llc)
anv_state_clflush(state);
}
static struct anv_state static struct anv_state
alloc_surface_state(struct anv_device *device, alloc_surface_state(struct anv_device *device,
struct anv_cmd_buffer *cmd_buffer) struct anv_cmd_buffer *cmd_buffer)
@@ -479,7 +448,7 @@ has_matching_storage_typed_format(const struct anv_device *device,
device->info.gen >= 9); device->info.gen >= 9);
} }
static VkComponentSwizzle static enum isl_channel_select
remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component, remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component,
struct anv_format_swizzle format_swizzle) struct anv_format_swizzle format_swizzle)
{ {
@@ -488,17 +457,17 @@ remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component,
switch (swizzle) { switch (swizzle) {
case VK_COMPONENT_SWIZZLE_ZERO: case VK_COMPONENT_SWIZZLE_ZERO:
return VK_COMPONENT_SWIZZLE_ZERO; return ISL_CHANNEL_SELECT_ZERO;
case VK_COMPONENT_SWIZZLE_ONE: case VK_COMPONENT_SWIZZLE_ONE:
return VK_COMPONENT_SWIZZLE_ONE; return ISL_CHANNEL_SELECT_ONE;
case VK_COMPONENT_SWIZZLE_R: case VK_COMPONENT_SWIZZLE_R:
return VK_COMPONENT_SWIZZLE_R + format_swizzle.r; return ISL_CHANNEL_SELECT_RED + format_swizzle.r;
case VK_COMPONENT_SWIZZLE_G: case VK_COMPONENT_SWIZZLE_G:
return VK_COMPONENT_SWIZZLE_R + format_swizzle.g; return ISL_CHANNEL_SELECT_RED + format_swizzle.g;
case VK_COMPONENT_SWIZZLE_B: case VK_COMPONENT_SWIZZLE_B:
return VK_COMPONENT_SWIZZLE_R + format_swizzle.b; return ISL_CHANNEL_SELECT_RED + format_swizzle.b;
case VK_COMPONENT_SWIZZLE_A: case VK_COMPONENT_SWIZZLE_A:
return VK_COMPONENT_SWIZZLE_R + format_swizzle.a; return ISL_CHANNEL_SELECT_RED + format_swizzle.a;
default: default:
unreachable("Invalid swizzle"); unreachable("Invalid swizzle");
} }
@@ -513,8 +482,6 @@ anv_image_view_init(struct anv_image_view *iview,
{ {
ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
VkImageViewCreateInfo mCreateInfo;
memcpy(&mCreateInfo, pCreateInfo, sizeof(VkImageViewCreateInfo));
assert(range->layerCount > 0); assert(range->layerCount > 0);
assert(range->baseMipLevel < image->levels); assert(range->baseMipLevel < image->levels);
@@ -549,18 +516,30 @@ anv_image_view_init(struct anv_image_view *iview,
struct anv_format_swizzle swizzle; struct anv_format_swizzle swizzle;
iview->format = anv_get_isl_format(pCreateInfo->format, iview->aspect_mask, iview->format = anv_get_isl_format(pCreateInfo->format, iview->aspect_mask,
image->tiling, &swizzle); image->tiling, &swizzle);
iview->swizzle.r = remap_swizzle(pCreateInfo->components.r,
VK_COMPONENT_SWIZZLE_R, swizzle);
iview->swizzle.g = remap_swizzle(pCreateInfo->components.g,
VK_COMPONENT_SWIZZLE_G, swizzle);
iview->swizzle.b = remap_swizzle(pCreateInfo->components.b,
VK_COMPONENT_SWIZZLE_B, swizzle);
iview->swizzle.a = remap_swizzle(pCreateInfo->components.a,
VK_COMPONENT_SWIZZLE_A, swizzle);
iview->base_layer = range->baseArrayLayer; iview->base_layer = range->baseArrayLayer;
iview->base_mip = range->baseMipLevel; iview->base_mip = range->baseMipLevel;
struct isl_view isl_view = {
.format = iview->format,
.base_level = range->baseMipLevel,
.levels = range->levelCount,
.base_array_layer = range->baseArrayLayer,
.array_len = range->layerCount,
.channel_select = {
remap_swizzle(pCreateInfo->components.r,
VK_COMPONENT_SWIZZLE_R, swizzle),
remap_swizzle(pCreateInfo->components.g,
VK_COMPONENT_SWIZZLE_G, swizzle),
remap_swizzle(pCreateInfo->components.b,
VK_COMPONENT_SWIZZLE_B, swizzle),
remap_swizzle(pCreateInfo->components.a,
VK_COMPONENT_SWIZZLE_A, swizzle),
},
};
struct isl_extent4d level0_extent_px;
if (!isl_format_is_compressed(iview->format) && if (!isl_format_is_compressed(iview->format) &&
isl_format_is_compressed(image->format->isl_format)) { isl_format_is_compressed(image->format->isl_format)) {
/* Scale the ImageView extent by the backing Image. This is used /* Scale the ImageView extent by the backing Image. This is used
@@ -570,31 +549,46 @@ anv_image_view_init(struct anv_image_view *iview,
*/ */
const struct isl_format_layout * isl_layout = image->format->isl_layout; const struct isl_format_layout * isl_layout = image->format->isl_layout;
iview->level_0_extent.depth = anv_minify(image->extent.depth, range->baseMipLevel); level0_extent_px.depth = anv_minify(image->extent.depth, range->baseMipLevel);
iview->level_0_extent.depth = DIV_ROUND_UP(iview->level_0_extent.depth, isl_layout->bd); level0_extent_px.depth = DIV_ROUND_UP(level0_extent_px.depth, isl_layout->bd);
iview->level_0_extent.height = isl_surf_get_array_pitch_el_rows(&surface->isl) * image->array_size; level0_extent_px.height = isl_surf_get_array_pitch_el_rows(&surface->isl) * image->array_size;
iview->level_0_extent.width = isl_surf_get_row_pitch_el(&surface->isl); level0_extent_px.width = isl_surf_get_row_pitch_el(&surface->isl);
mCreateInfo.subresourceRange.baseMipLevel = 0; isl_view.base_level = 0;
mCreateInfo.subresourceRange.baseArrayLayer = 0; isl_view.base_array_layer = 0;
} else { } else {
iview->level_0_extent.width = image->extent.width; level0_extent_px.width = image->extent.width;
iview->level_0_extent.height = image->extent.height; level0_extent_px.height = image->extent.height;
iview->level_0_extent.depth = image->extent.depth; level0_extent_px.depth = image->extent.depth;
} }
iview->extent = (VkExtent3D) { iview->extent = (VkExtent3D) {
.width = anv_minify(iview->level_0_extent.width , range->baseMipLevel), .width = anv_minify(image->extent.width , range->baseMipLevel),
.height = anv_minify(iview->level_0_extent.height, range->baseMipLevel), .height = anv_minify(image->extent.height, range->baseMipLevel),
.depth = anv_minify(iview->level_0_extent.depth , range->baseMipLevel), .depth = anv_minify(image->extent.depth , range->baseMipLevel),
}; };
isl_surf_usage_flags_t cube_usage;
if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE ||
pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
cube_usage = ISL_SURF_USAGE_CUBE_BIT;
} else {
cube_usage = 0;
}
if (image->usage & VK_IMAGE_USAGE_SAMPLED_BIT) { if (image->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
iview->sampler_surface_state = alloc_surface_state(device, cmd_buffer); iview->sampler_surface_state = alloc_surface_state(device, cmd_buffer);
anv_fill_image_surface_state(device, iview->sampler_surface_state, isl_view.usage = cube_usage | ISL_SURF_USAGE_TEXTURE_BIT;
iview, &mCreateInfo, isl_surf_fill_state(&device->isl_dev,
VK_IMAGE_USAGE_SAMPLED_BIT); iview->sampler_surface_state.map,
.surf = &surface->isl,
.view = &isl_view,
.mocs = device->default_mocs,
.level0_extent_px = level0_extent_px);
if (!device->info.has_llc)
anv_state_clflush(iview->sampler_surface_state);
} else { } else {
iview->sampler_surface_state.alloc_size = 0; iview->sampler_surface_state.alloc_size = 0;
} }
@@ -602,9 +596,16 @@ anv_image_view_init(struct anv_image_view *iview,
if (image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { if (image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
iview->color_rt_surface_state = alloc_surface_state(device, cmd_buffer); iview->color_rt_surface_state = alloc_surface_state(device, cmd_buffer);
anv_fill_image_surface_state(device, iview->color_rt_surface_state, isl_view.usage = cube_usage | ISL_SURF_USAGE_RENDER_TARGET_BIT;
iview, &mCreateInfo, isl_surf_fill_state(&device->isl_dev,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); iview->color_rt_surface_state.map,
.surf = &surface->isl,
.view = &isl_view,
.mocs = device->default_mocs,
.level0_extent_px = level0_extent_px);
if (!device->info.has_llc)
anv_state_clflush(iview->color_rt_surface_state);
} else { } else {
iview->color_rt_surface_state.alloc_size = 0; iview->color_rt_surface_state.alloc_size = 0;
} }
@@ -612,16 +613,23 @@ anv_image_view_init(struct anv_image_view *iview,
if (image->usage & VK_IMAGE_USAGE_STORAGE_BIT) { if (image->usage & VK_IMAGE_USAGE_STORAGE_BIT) {
iview->storage_surface_state = alloc_surface_state(device, cmd_buffer); iview->storage_surface_state = alloc_surface_state(device, cmd_buffer);
if (has_matching_storage_typed_format(device, iview->format)) if (has_matching_storage_typed_format(device, iview->format)) {
anv_fill_image_surface_state(device, iview->storage_surface_state, isl_view.usage = cube_usage | ISL_SURF_USAGE_STORAGE_BIT;
iview, &mCreateInfo, isl_surf_fill_state(&device->isl_dev,
VK_IMAGE_USAGE_STORAGE_BIT); iview->storage_surface_state.map,
else .surf = &surface->isl,
.view = &isl_view,
.mocs = device->default_mocs,
.level0_extent_px = level0_extent_px);
} else {
anv_fill_buffer_surface_state(device, iview->storage_surface_state, anv_fill_buffer_surface_state(device, iview->storage_surface_state,
ISL_FORMAT_RAW, ISL_FORMAT_RAW,
iview->offset, iview->offset,
iview->bo->size - iview->offset, 1); iview->bo->size - iview->offset, 1);
}
if (!device->info.has_llc)
anv_state_clflush(iview->storage_surface_state);
} else { } else {
iview->storage_surface_state.alloc_size = 0; iview->storage_surface_state.alloc_size = 0;
} }