fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-08 09:08:10 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

v3dv: make v3dv_image_view derive from vk_image_view

Browse source 
Reviewed-by: Alejandro Piñeiro <apinheiro@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/12668>
This commit is contained in:
Iago Toral Quiroga 2021-07-26 13:23:30 +02:00 • committed by Marge Bot
parent f0e299fc5c
commit 0496a39b1f
9 changed files with 78 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
src/broadcom/vulkan/v3dv_cmd_buffer.c
View file

@ -1015,26 +1015,28 @@ cmd_buffer_subpass_handle_pending_resolves(struct v3dv_cmd_buffer *cmd_buffer)
.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR,
.srcSubresource = {
VK_IMAGE_ASPECT_COLOR_BIT,
src_iview->base_level,
src_iview->first_layer,
src_iview->last_layer - src_iview->first_layer + 1,
src_iview->vk.base_mip_level,
src_iview->vk.base_array_layer,
src_iview->vk.layer_count,
},
.srcOffset = { 0, 0, 0 },
.dstSubresource = {
VK_IMAGE_ASPECT_COLOR_BIT,
dst_iview->base_level,
dst_iview->first_layer,
dst_iview->last_layer - dst_iview->first_layer + 1,
dst_iview->vk.base_mip_level,
dst_iview->vk.base_array_layer,
dst_iview->vk.layer_count,
},
.dstOffset = { 0, 0, 0 },
.extent = src_iview->image->vk.extent,
.extent = src_iview->vk.image->extent,
};
struct v3dv_image *src_image = (struct v3dv_image *) src_iview->vk.image;
struct v3dv_image *dst_image = (struct v3dv_image *) dst_iview->vk.image;
VkResolveImageInfo2KHR resolve_info = {
.sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR,
.srcImage = v3dv_image_to_handle(src_iview->image),
.srcImage = v3dv_image_to_handle(src_image),
.srcImageLayout = VK_IMAGE_LAYOUT_GENERAL,
.dstImage = v3dv_image_to_handle(dst_iview->image),
.dstImage = v3dv_image_to_handle(dst_image),
.dstImageLayout = VK_IMAGE_LAYOUT_GENERAL,
.regionCount = 1,
.pRegions = &region,

11
src/broadcom/vulkan/v3dv_descriptor_set.c
View file

@ -240,7 +240,7 @@ v3dv_descriptor_map_get_texture_format(struct v3dv_descriptor_state *descriptor_
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
assert(descriptor->image_view);
*out_vk_format = descriptor->image_view->vk_format;
*out_vk_format = descriptor->image_view->vk.format;
return descriptor->image_view->format;
default:
unreachable("descriptor type doesn't has a texture format");
@ -266,9 +266,12 @@ v3dv_descriptor_map_get_texture_bo(struct v3dv_descriptor_state *descriptor_stat
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: {
assert(descriptor->image_view);
return descriptor->image_view->image->mem->bo;
struct v3dv_image *image =
(struct v3dv_image *) descriptor->image_view->vk.image;
return image->mem->bo;
}
default:
unreachable("descriptor type doesn't has a texture bo");
}
@ -918,7 +921,7 @@ write_image_descriptor(struct v3dv_device *device,
if (iview) {
const uint32_t tex_state_index =
iview->type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY ||
iview->vk.view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY ||
desc_type != VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? 0 : 1;
memcpy(desc_map,
iview->texture_shader_state[tex_state_index],

2
src/broadcom/vulkan/v3dv_device.c
View file

@ -2434,7 +2434,7 @@ v3dv_CreateFramebuffer(VkDevice _device,
for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) {
framebuffer->attachments[i] =
v3dv_image_view_from_handle(pCreateInfo->pAttachments[i]);
if (framebuffer->attachments[i]->aspects & VK_IMAGE_ASPECT_COLOR_BIT)
if (framebuffer->attachments[i]->vk.aspects & VK_IMAGE_ASPECT_COLOR_BIT)
framebuffer->color_attachment_count++;
}

79
src/broadcom/vulkan/v3dv_image.c
View file

@ -452,11 +452,9 @@ v3dv_image_type_to_view_type(VkImageType type)
}
static enum pipe_swizzle
vk_component_mapping_to_pipe_swizzle(VkComponentSwizzle comp,
VkComponentSwizzle swz)
vk_component_mapping_to_pipe_swizzle(VkComponentSwizzle swz)
{
if (swz == VK_COMPONENT_SWIZZLE_IDENTITY)
swz = comp;
assert(swz != VK_COMPONENT_SWIZZLE_IDENTITY);
switch (swz) {
case VK_COMPONENT_SWIZZLE_ZERO:
@ -486,59 +484,15 @@ v3dv_CreateImageView(VkDevice _device,
V3DV_FROM_HANDLE(v3dv_image, image, pCreateInfo->image);
struct v3dv_image_view *iview;
iview = vk_object_zalloc(&device->vk, pAllocator, sizeof(*iview),
VK_OBJECT_TYPE_IMAGE_VIEW);
iview = vk_image_view_create(&device->vk, pCreateInfo, pAllocator,
sizeof(*iview));
if (iview == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
assert(range->layerCount > 0);
assert(range->baseMipLevel < image->vk.mip_levels);
#ifdef DEBUG
switch (image->vk.image_type) {
case VK_IMAGE_TYPE_1D:
case VK_IMAGE_TYPE_2D:
assert(range->baseArrayLayer +
vk_image_subresource_layer_count(&image->vk, range) - 1 <=
image->vk.array_layers);
break;
case VK_IMAGE_TYPE_3D:
assert(range->baseArrayLayer +
vk_image_subresource_layer_count(&image->vk, range) - 1
<= u_minify(image->vk.extent.depth, range->baseMipLevel));
/* VK_KHR_maintenance1 */
assert(pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D ||
((image->vk.create_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) &&
range->levelCount == 1 && range->layerCount == 1));
assert(pCreateInfo->viewType != VK_IMAGE_VIEW_TYPE_2D_ARRAY ||
((image->vk.create_flags & VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT) &&
range->levelCount == 1));
break;
default:
unreachable("bad VkImageType");
}
#endif
iview->image = image;
iview->aspects = range->aspectMask;
iview->type = pCreateInfo->viewType;
iview->base_level = range->baseMipLevel;
iview->max_level = iview->base_level +
vk_image_subresource_level_count(&image->vk, range) - 1;
iview->extent = (VkExtent3D) {
.width = u_minify(image->vk.extent.width , iview->base_level),
.height = u_minify(image->vk.extent.height, iview->base_level),
.depth = u_minify(image->vk.extent.depth , iview->base_level),
};
iview->first_layer = range->baseArrayLayer;
iview->last_layer = range->baseArrayLayer +
vk_image_subresource_layer_count(&image->vk, range) - 1;
iview->offset =
v3dv_layer_offset(image, iview->base_level, iview->first_layer);
iview->offset = v3dv_layer_offset(image, iview->vk.base_mip_level,
iview->vk.base_array_layer);
/* If we have D24S8 format but the view only selects the stencil aspect
* we want to re-interpret the format as RGBA8_UINT, then map our stencil
@ -562,25 +516,22 @@ v3dv_CreateImageView(VkDevice _device,
* better to reimplement the latter using vk component
*/
image_view_swizzle[0] =
vk_component_mapping_to_pipe_swizzle(VK_COMPONENT_SWIZZLE_R,
pCreateInfo->components.r);
vk_component_mapping_to_pipe_swizzle(iview->vk.swizzle.r);
image_view_swizzle[1] =
vk_component_mapping_to_pipe_swizzle(VK_COMPONENT_SWIZZLE_G,
pCreateInfo->components.g);
vk_component_mapping_to_pipe_swizzle(iview->vk.swizzle.g);
image_view_swizzle[2] =
vk_component_mapping_to_pipe_swizzle(VK_COMPONENT_SWIZZLE_B,
pCreateInfo->components.b);
vk_component_mapping_to_pipe_swizzle(iview->vk.swizzle.b);
image_view_swizzle[3] =
vk_component_mapping_to_pipe_swizzle(VK_COMPONENT_SWIZZLE_A,
pCreateInfo->components.a);
vk_component_mapping_to_pipe_swizzle(iview->vk.swizzle.a);
}
iview->vk_format = format;
iview->vk.format = format;
iview->format = v3dv_X(device, get_format)(format);
assert(iview->format && iview->format->supported);
if (vk_format_is_depth_or_stencil(iview->vk_format)) {
iview->internal_type = v3dv_X(device, get_internal_depth_type)(iview->vk_format);
if (vk_format_is_depth_or_stencil(iview->vk.format)) {
iview->internal_type =
v3dv_X(device, get_internal_depth_type)(iview->vk.format);
} else {
v3dv_X(device, get_internal_type_bpp_for_output_format)
(iview->format->rt_type, &iview->internal_type, &iview->internal_bpp);
@ -609,7 +560,7 @@ v3dv_DestroyImageView(VkDevice _device,
if (image_view == NULL)
return;
vk_object_free(&device->vk, pAllocator, image_view);
vk_image_view_destroy(&device->vk, pAllocator, &image_view->vk);
}
VKAPI_ATTR VkResult VKAPI_CALL

13
src/broadcom/vulkan/v3dv_private.h
View file

@ -550,23 +550,12 @@ VkImageViewType v3dv_image_type_to_view_type(VkImageType type);
#define V3DV_STENCIL_CFG_LENGTH 6
struct v3dv_image_view {
struct vk_object_base base;
struct vk_image_view vk;
struct v3dv_image *image;
VkImageAspectFlags aspects;
VkExtent3D extent;
VkImageViewType type;
VkFormat vk_format;
const struct v3dv_format *format;
bool swap_rb;
uint32_t internal_bpp;
uint32_t internal_type;
uint32_t base_level;
uint32_t max_level;
uint32_t first_layer;
uint32_t last_layer;
uint32_t offset;
/* Precomputed (composed from createinfo->components and formar swizzle)

20
src/broadcom/vulkan/v3dv_uniforms.c
View file

@ -312,26 +312,26 @@ get_texture_size_from_image_view(struct v3dv_image_view *image_view,
/* We don't u_minify the values, as we are using the image_view
* extents
*/
return image_view->extent.width;
return image_view->vk.extent.width;
case QUNIFORM_IMAGE_HEIGHT:
case QUNIFORM_TEXTURE_HEIGHT:
return image_view->extent.height;
return image_view->vk.extent.height;
case QUNIFORM_IMAGE_DEPTH:
case QUNIFORM_TEXTURE_DEPTH:
return image_view->extent.depth;
return image_view->vk.extent.depth;
case QUNIFORM_IMAGE_ARRAY_SIZE:
case QUNIFORM_TEXTURE_ARRAY_SIZE:
if (image_view->type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
return image_view->last_layer - image_view->first_layer + 1;
if (image_view->vk.view_type != VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) {
return image_view->vk.layer_count;
} else {
assert((image_view->last_layer - image_view->first_layer + 1) % 6 == 0);
return (image_view->last_layer - image_view->first_layer + 1) / 6;
assert(image_view->vk.layer_count % 6 == 0);
return image_view->vk.layer_count / 6;
}
case QUNIFORM_TEXTURE_LEVELS:
return image_view->max_level - image_view->base_level + 1;
return image_view->vk.level_count;
case QUNIFORM_TEXTURE_SAMPLES:
assert(image_view->image);
return image_view->image->vk.samples;
assert(image_view->vk.image);
return image_view->vk.image->samples;
default:
unreachable("Bad texture size field");
}

31
src/broadcom/vulkan/v3dvx_cmd_buffer.c
View file

@ -105,11 +105,12 @@ cmd_buffer_render_pass_emit_load(struct v3dv_cmd_buffer *cmd_buffer,
uint32_t layer,
uint32_t buffer)
{
const struct v3dv_image *image = iview->image;
const struct v3d_resource_slice *slice = &image->slices[iview->base_level];
uint32_t layer_offset = v3dv_layer_offset(image,
iview->base_level,
iview->first_layer + layer);
const struct v3dv_image *image = (struct v3dv_image *) iview->vk.image;
const struct v3d_resource_slice *slice =
&image->slices[iview->vk.base_mip_level];
uint32_t layer_offset =
v3dv_layer_offset(image, iview->vk.base_mip_level,
iview->vk.base_array_layer + layer);
cl_emit(cl, LOAD_TILE_BUFFER_GENERAL, load) {
load.buffer_to_load = buffer;
@ -290,11 +291,12 @@ cmd_buffer_render_pass_emit_store(struct v3dv_cmd_buffer *cmd_buffer,
{
const struct v3dv_image_view *iview =
cmd_buffer->state.framebuffer->attachments[attachment_idx];
const struct v3dv_image *image = iview->image;
const struct v3d_resource_slice *slice = &image->slices[iview->base_level];
const struct v3dv_image *image = (struct v3dv_image *) iview->vk.image;
const struct v3d_resource_slice *slice =
&image->slices[iview->vk.base_mip_level];
uint32_t layer_offset = v3dv_layer_offset(image,
iview->base_level,
iview->first_layer + layer);
iview->vk.base_mip_level,
iview->vk.base_array_layer + layer);
cl_emit(cl, STORE_TILE_BUFFER_GENERAL, store) {
store.buffer_to_store = buffer;
@ -843,8 +845,9 @@ v3dX(cmd_buffer_emit_render_pass_rcl)(struct v3dv_cmd_buffer *cmd_buffer)
struct v3dv_image_view *iview =
state->framebuffer->attachments[attachment_idx];
const struct v3dv_image *image = iview->image;
const struct v3d_resource_slice *slice = &image->slices[iview->base_level];
const struct v3dv_image *image = (struct v3dv_image *) iview->vk.image;
const struct v3d_resource_slice *slice =
&image->slices[iview->vk.base_mip_level];
const uint32_t *clear_color =
&state->attachments[attachment_idx].clear_value.color[0];
@ -2265,13 +2268,13 @@ v3dX(cmd_buffer_render_pass_setup_render_target)(struct v3dv_cmd_buffer *cmd_buf
const struct v3dv_framebuffer *framebuffer = state->framebuffer;
assert(attachment_idx < framebuffer->attachment_count);
struct v3dv_image_view *iview = framebuffer->attachments[attachment_idx];
assert(iview->aspects & VK_IMAGE_ASPECT_COLOR_BIT);
assert(iview->vk.aspects & VK_IMAGE_ASPECT_COLOR_BIT);
*rt_bpp = iview->internal_bpp;
*rt_type = iview->internal_type;
if (vk_format_is_int(iview->vk_format))
if (vk_format_is_int(iview->vk.format))
*rt_clamp = V3D_RENDER_TARGET_CLAMP_INT;
else if (vk_format_is_srgb(iview->vk_format))
else if (vk_format_is_srgb(iview->vk.format))
*rt_clamp = V3D_RENDER_TARGET_CLAMP_NORM;
else
*rt_clamp = V3D_RENDER_TARGET_CLAMP_NONE;

10
src/broadcom/vulkan/v3dvx_device.c
View file

@ -255,10 +255,10 @@ v3dX(framebuffer_compute_internal_bpp_msaa)(
const struct v3dv_image_view *att = framebuffer->attachments[att_idx];
assert(att);
if (att->aspects & VK_IMAGE_ASPECT_COLOR_BIT)
if (att->vk.aspects & VK_IMAGE_ASPECT_COLOR_BIT)
*max_bpp = MAX2(*max_bpp, att->internal_bpp);
if (att->image->vk.samples > VK_SAMPLE_COUNT_1_BIT)
if (att->vk.image->samples > VK_SAMPLE_COUNT_1_BIT)
*msaa = true;
}
@ -267,7 +267,7 @@ v3dX(framebuffer_compute_internal_bpp_msaa)(
framebuffer->attachments[subpass->ds_attachment.attachment];
assert(att);
if (att->image->vk.samples > VK_SAMPLE_COUNT_1_BIT)
if (att->vk.image->samples > VK_SAMPLE_COUNT_1_BIT)
*msaa = true;
}
@ -279,10 +279,10 @@ v3dX(framebuffer_compute_internal_bpp_msaa)(
const struct v3dv_image_view *att = framebuffer->attachments[i];
assert(att);
if (att->aspects & VK_IMAGE_ASPECT_COLOR_BIT)
if (att->vk.aspects & VK_IMAGE_ASPECT_COLOR_BIT)
*max_bpp = MAX2(*max_bpp, att->internal_bpp);
if (att->image->vk.samples > VK_SAMPLE_COUNT_1_BIT)
if (att->vk.image->samples > VK_SAMPLE_COUNT_1_BIT)
*msaa = true;
}

21
src/broadcom/vulkan/v3dvx_image.c
View file

@ -61,11 +61,11 @@ pack_texture_shader_state_helper(struct v3dv_device *device,
bool for_cube_map_array_storage)
{
assert(!for_cube_map_array_storage ||
image_view->type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY);
image_view->vk.view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY);
const uint32_t index = for_cube_map_array_storage ? 1 : 0;
assert(image_view->image);
const struct v3dv_image *image = image_view->image;
assert(image_view->vk.image);
const struct v3dv_image *image = (struct v3dv_image *) image_view->vk.image;
assert(image->vk.samples == VK_SAMPLE_COUNT_1_BIT ||
image->vk.samples == VK_SAMPLE_COUNT_4_BIT);
@ -91,8 +91,9 @@ pack_texture_shader_state_helper(struct v3dv_device *device,
tex.extended = true;
}
tex.base_level = image_view->base_level;
tex.max_level = image_view->max_level;
tex.base_level = image_view->vk.base_mip_level;
tex.max_level = image_view->vk.base_mip_level +
image_view->vk.level_count - 1;
tex.swizzle_r = translate_swizzle(image_view->swizzle[0]);
tex.swizzle_g = translate_swizzle(image_view->swizzle[1]);
@ -104,14 +105,14 @@ pack_texture_shader_state_helper(struct v3dv_device *device,
if (image->vk.image_type == VK_IMAGE_TYPE_3D) {
tex.image_depth = image->vk.extent.depth;
} else {
tex.image_depth = (image_view->last_layer - image_view->first_layer) + 1;
tex.image_depth = image_view->vk.layer_count;
}
/* Empirical testing with CTS shows that when we are sampling from cube
* arrays we want to set image depth to layers / 6, but not when doing
* image load/store.
*/
if (image_view->type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY &&
if (image_view->vk.view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY &&
!for_cube_map_array_storage) {
assert(tex.image_depth % 6 == 0);
tex.image_depth /= 6;
@ -131,7 +132,7 @@ pack_texture_shader_state_helper(struct v3dv_device *device,
tex.array_stride_64_byte_aligned = image->cube_map_stride / 64;
tex.srgb = vk_format_is_srgb(image_view->vk_format);
tex.srgb = vk_format_is_srgb(image_view->vk.format);
/* At this point we don't have the job. That's the reason the first
* parameter is NULL, to avoid a crash when cl_pack_emit_reloc tries to
@ -140,7 +141,7 @@ pack_texture_shader_state_helper(struct v3dv_device *device,
*/
const uint32_t base_offset =
image->mem->bo->offset +
v3dv_layer_offset(image, 0, image_view->first_layer);
v3dv_layer_offset(image, 0, image_view->vk.base_array_layer);
tex.texture_base_pointer = v3dv_cl_address(NULL, base_offset);
}
}
@ -150,7 +151,7 @@ v3dX(pack_texture_shader_state)(struct v3dv_device *device,
struct v3dv_image_view *iview)
{
pack_texture_shader_state_helper(device, iview, false);
if (iview->type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
if (iview->vk.view_type == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
pack_texture_shader_state_helper(device, iview, true);
}