From abb2b43c9c741c4c3a020a49985233816fc5e14d Mon Sep 17 00:00:00 2001 From: Bas Nieuwenhuizen Date: Sat, 30 Jan 2021 18:49:41 +0100 Subject: [PATCH] radv: Remove VK_SWIZZLE_*. Values are the same as PIPE_SWIZZLE_*. Reviewed-by: Samuel Pitoiset Part-of: --- src/amd/vulkan/radv_device.c | 2 +- src/amd/vulkan/radv_formats.c | 6 +-- src/amd/vulkan/radv_image.c | 46 +++++++++---------- src/amd/vulkan/radv_meta_clear.c | 12 ++--- .../vulkan/radv_nir_lower_ycbcr_textures.c | 18 ++++---- src/amd/vulkan/vk_format.h | 33 +++++-------- src/amd/vulkan/vk_format_table.py | 14 +++--- 7 files changed, 60 insertions(+), 71 deletions(-) diff --git a/src/amd/vulkan/radv_device.c b/src/amd/vulkan/radv_device.c index 0a062a5acac..855a2bd5f5c 100644 --- a/src/amd/vulkan/radv_device.c +++ b/src/amd/vulkan/radv_device.c @@ -6860,7 +6860,7 @@ radv_initialise_color_surface(struct radv_device *device, memset(cb, 0, sizeof(*cb)); /* Intensity is implemented as Red, so treat it that way. */ - cb->cb_color_attrib = S_028C74_FORCE_DST_ALPHA_1(desc->swizzle[3] == VK_SWIZZLE_1); + cb->cb_color_attrib = S_028C74_FORCE_DST_ALPHA_1(desc->swizzle[3] == PIPE_SWIZZLE_1); va = radv_buffer_get_va(iview->bo) + iview->image->offset; diff --git a/src/amd/vulkan/radv_formats.c b/src/amd/vulkan/radv_formats.c index 24b5edac2f1..610f38b9c23 100644 --- a/src/amd/vulkan/radv_formats.c +++ b/src/amd/vulkan/radv_formats.c @@ -947,7 +947,7 @@ unsigned radv_translate_colorswap(VkFormat format, bool do_endian_swap) { const struct vk_format_description *desc = vk_format_description(format); -#define HAS_SWIZZLE(chan,swz) (desc->swizzle[chan] == VK_SWIZZLE_##swz) +#define HAS_SWIZZLE(chan,swz) (desc->swizzle[chan] == PIPE_SWIZZLE_##swz) if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) return V_028C70_SWAP_STD; @@ -2000,8 +2000,8 @@ bool radv_dcc_formats_compatible(VkFormat format1, /* Swizzles must be the same. */ for (i = 0; i < desc1->nr_channels; i++) - if (desc1->swizzle[i] <= VK_SWIZZLE_W && - desc2->swizzle[i] <= VK_SWIZZLE_W && + if (desc1->swizzle[i] <= PIPE_SWIZZLE_W && + desc2->swizzle[i] <= PIPE_SWIZZLE_W && desc1->swizzle[i] != desc2->swizzle[i]) return false; diff --git a/src/amd/vulkan/radv_image.c b/src/amd/vulkan/radv_image.c index 8acbbabd1b3..efef2469bee 100644 --- a/src/amd/vulkan/radv_image.c +++ b/src/amd/vulkan/radv_image.c @@ -519,24 +519,24 @@ si_tile_mode_index(const struct radv_image_plane *plane, unsigned level, bool st static unsigned radv_map_swizzle(unsigned swizzle) { switch (swizzle) { - case VK_SWIZZLE_Y: + case PIPE_SWIZZLE_Y: return V_008F0C_SQ_SEL_Y; - case VK_SWIZZLE_Z: + case PIPE_SWIZZLE_Z: return V_008F0C_SQ_SEL_Z; - case VK_SWIZZLE_W: + case PIPE_SWIZZLE_W: return V_008F0C_SQ_SEL_W; - case VK_SWIZZLE_0: + case PIPE_SWIZZLE_0: return V_008F0C_SQ_SEL_0; - case VK_SWIZZLE_1: + case PIPE_SWIZZLE_1: return V_008F0C_SQ_SEL_1; - default: /* VK_SWIZZLE_X */ + default: /* PIPE_SWIZZLE_X */ return V_008F0C_SQ_SEL_X; } } static void radv_compose_swizzle(const struct vk_format_description *desc, - const VkComponentMapping *mapping, enum vk_swizzle swizzle[4]) + const VkComponentMapping *mapping, enum pipe_swizzle swizzle[4]) { if (desc->format == VK_FORMAT_R64_UINT || desc->format == VK_FORMAT_R64_SINT) { /* 64-bit formats only support storage images and storage images @@ -548,16 +548,16 @@ radv_compose_swizzle(const struct vk_format_description *desc, * by loads to create the w component, which has to be 0 for * NULL descriptors. */ - swizzle[0] = VK_SWIZZLE_X; - swizzle[1] = VK_SWIZZLE_Y; - swizzle[2] = VK_SWIZZLE_1; - swizzle[3] = VK_SWIZZLE_0; + swizzle[0] = PIPE_SWIZZLE_X; + swizzle[1] = PIPE_SWIZZLE_Y; + swizzle[2] = PIPE_SWIZZLE_1; + swizzle[3] = PIPE_SWIZZLE_0; } else if (!mapping) { for (unsigned i = 0; i < 4; i++) swizzle[i] = desc->swizzle[i]; } else if (desc->colorspace == VK_FORMAT_COLORSPACE_ZS) { const unsigned char swizzle_xxxx[4] = { - VK_SWIZZLE_X, VK_SWIZZLE_0, VK_SWIZZLE_0, VK_SWIZZLE_1 + PIPE_SWIZZLE_X, PIPE_SWIZZLE_0, PIPE_SWIZZLE_0, PIPE_SWIZZLE_1 }; vk_format_compose_swizzles(mapping, swizzle_xxxx, swizzle); } else { @@ -579,7 +579,7 @@ radv_make_buffer_descriptor(struct radv_device *device, uint64_t va = gpu_address + buffer->offset; unsigned num_format, data_format; int first_non_void; - enum vk_swizzle swizzle[4]; + enum pipe_swizzle swizzle[4]; desc = vk_format_description(vk_format); first_non_void = vk_format_get_first_non_void_channel(vk_format); stride = desc->block.bits / 8; @@ -772,29 +772,29 @@ static unsigned radv_tex_dim(VkImageType image_type, VkImageViewType view_type, } } -static unsigned gfx9_border_color_swizzle(const enum vk_swizzle swizzle[4]) +static unsigned gfx9_border_color_swizzle(const enum pipe_swizzle swizzle[4]) { unsigned bc_swizzle = V_008F20_BC_SWIZZLE_XYZW; - if (swizzle[3] == VK_SWIZZLE_X) { + if (swizzle[3] == PIPE_SWIZZLE_X) { /* For the pre-defined border color values (white, opaque * black, transparent black), the only thing that matters is * that the alpha channel winds up in the correct place * (because the RGB channels are all the same) so either of * these enumerations will work. */ - if (swizzle[2] == VK_SWIZZLE_Y) + if (swizzle[2] == PIPE_SWIZZLE_Y) bc_swizzle = V_008F20_BC_SWIZZLE_WZYX; else bc_swizzle = V_008F20_BC_SWIZZLE_WXYZ; - } else if (swizzle[0] == VK_SWIZZLE_X) { - if (swizzle[1] == VK_SWIZZLE_Y) + } else if (swizzle[0] == PIPE_SWIZZLE_X) { + if (swizzle[1] == PIPE_SWIZZLE_Y) bc_swizzle = V_008F20_BC_SWIZZLE_XYZW; else bc_swizzle = V_008F20_BC_SWIZZLE_XWYZ; - } else if (swizzle[1] == VK_SWIZZLE_X) { + } else if (swizzle[1] == PIPE_SWIZZLE_X) { bc_swizzle = V_008F20_BC_SWIZZLE_YXWZ; - } else if (swizzle[2] == VK_SWIZZLE_X) { + } else if (swizzle[2] == PIPE_SWIZZLE_X) { bc_swizzle = V_008F20_BC_SWIZZLE_ZYXW; } @@ -806,7 +806,7 @@ bool vi_alpha_is_on_msb(struct radv_device *device, VkFormat format) const struct vk_format_description *desc = vk_format_description(format); if (device->physical_device->rad_info.chip_class >= GFX10 && desc->nr_channels == 1) - return desc->swizzle[3] == VK_SWIZZLE_X; + return desc->swizzle[3] == PIPE_SWIZZLE_X; return radv_translate_colorswap(format, false) <= 1; } @@ -827,7 +827,7 @@ gfx10_make_texture_descriptor(struct radv_device *device, uint32_t *fmask_state) { const struct vk_format_description *desc; - enum vk_swizzle swizzle[4]; + enum pipe_swizzle swizzle[4]; unsigned img_format; unsigned type; @@ -957,7 +957,7 @@ si_make_texture_descriptor(struct radv_device *device, uint32_t *fmask_state) { const struct vk_format_description *desc; - enum vk_swizzle swizzle[4]; + enum pipe_swizzle swizzle[4]; int first_non_void; unsigned num_format, data_format, type; diff --git a/src/amd/vulkan/radv_meta_clear.c b/src/amd/vulkan/radv_meta_clear.c index 7401666a78f..f97f26955cd 100644 --- a/src/amd/vulkan/radv_meta_clear.c +++ b/src/amd/vulkan/radv_meta_clear.c @@ -1542,9 +1542,9 @@ static void vi_get_fast_clear_parameters(struct radv_device *device, return; for (int i = 0; i < 4; i++) { - int index = desc->swizzle[i] - VK_SWIZZLE_X; - if (desc->swizzle[i] < VK_SWIZZLE_X || - desc->swizzle[i] > VK_SWIZZLE_W) + int index = desc->swizzle[i] - PIPE_SWIZZLE_X; + if (desc->swizzle[i] < PIPE_SWIZZLE_X || + desc->swizzle[i] > PIPE_SWIZZLE_W) continue; if (desc->channel[i].pure_integer && @@ -1586,9 +1586,9 @@ static void vi_get_fast_clear_parameters(struct radv_device *device, for (int i = 0; i < 4; ++i) if (values[i] != main_value && - desc->swizzle[i] - VK_SWIZZLE_X != extra_channel && - desc->swizzle[i] >= VK_SWIZZLE_X && - desc->swizzle[i] <= VK_SWIZZLE_W) + desc->swizzle[i] - PIPE_SWIZZLE_X != extra_channel && + desc->swizzle[i] >= PIPE_SWIZZLE_X && + desc->swizzle[i] <= PIPE_SWIZZLE_W) return; *can_avoid_fast_clear_elim = true; diff --git a/src/amd/vulkan/radv_nir_lower_ycbcr_textures.c b/src/amd/vulkan/radv_nir_lower_ycbcr_textures.c index c63c4ce6124..db1a918dcd6 100644 --- a/src/amd/vulkan/radv_nir_lower_ycbcr_textures.c +++ b/src/amd/vulkan/radv_nir_lower_ycbcr_textures.c @@ -190,7 +190,7 @@ build_swizzled_components(nir_builder *builder, nir_ssa_def **plane_values) { struct swizzle_info plane_swizzle = get_plane_swizzles(format); - enum vk_swizzle swizzles[4]; + enum pipe_swizzle swizzles[4]; nir_ssa_def *values[4]; vk_format_compose_swizzles(&mapping, (const unsigned char[4]){0,1,2,3}, swizzles); @@ -200,20 +200,20 @@ build_swizzled_components(nir_builder *builder, for (unsigned i = 0; i < 4; ++i) { switch(swizzles[i]) { - case VK_SWIZZLE_X: - case VK_SWIZZLE_Y: - case VK_SWIZZLE_Z: - case VK_SWIZZLE_W: { - unsigned channel = swizzles[i] - VK_SWIZZLE_X; + case PIPE_SWIZZLE_X: + case PIPE_SWIZZLE_Y: + case PIPE_SWIZZLE_Z: + case PIPE_SWIZZLE_W: { + unsigned channel = swizzles[i] - PIPE_SWIZZLE_X; values[i] = nir_channel(builder, plane_values[plane_swizzle.plane[channel]], plane_swizzle.swizzle[channel]); break; } - case VK_SWIZZLE_0: + case PIPE_SWIZZLE_0: values[i] = zero; break; - case VK_SWIZZLE_1: + case PIPE_SWIZZLE_1: values[i] = one; break; default: @@ -285,7 +285,7 @@ try_lower_tex_ycbcr(const struct radv_pipeline_layout *layout, nir_ssa_def *result = build_swizzled_components(builder, format, ycbcr_sampler->components, plane_values); if (state.conversion->ycbcr_model != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY) { VkFormat first_format = vk_format_get_plane_format(format, 0); - uint32_t bits = vk_format_get_component_bits(first_format, VK_FORMAT_COLORSPACE_RGB, VK_SWIZZLE_X); + uint32_t bits = vk_format_get_component_bits(first_format, VK_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_X); /* TODO: swizzle and bpcs */ uint32_t bpcs[3] = {bits, bits, bits}; result = nir_convert_ycbcr_to_rgb(builder, diff --git a/src/amd/vulkan/vk_format.h b/src/amd/vulkan/vk_format.h index 06efe46128b..da2d1a7942d 100644 --- a/src/amd/vulkan/vk_format.h +++ b/src/amd/vulkan/vk_format.h @@ -198,17 +198,6 @@ vk_format_get_first_non_void_channel(VkFormat format) return util_format_get_first_non_void_channel(vk_format_to_pipe_format(format)); } -enum vk_swizzle { - VK_SWIZZLE_X, - VK_SWIZZLE_Y, - VK_SWIZZLE_Z, - VK_SWIZZLE_W, - VK_SWIZZLE_0, - VK_SWIZZLE_1, - VK_SWIZZLE_NONE, - VK_SWIZZLE_MAX, /**< Number of enums counter (must be last) */ -}; - static inline VkImageAspectFlags vk_format_aspects(VkFormat format) { @@ -234,21 +223,21 @@ vk_format_aspects(VkFormat format) } } -static inline enum vk_swizzle +static inline enum pipe_swizzle radv_swizzle_conv(VkComponentSwizzle component, const unsigned char chan[4], VkComponentSwizzle vk_swiz) { if (vk_swiz == VK_COMPONENT_SWIZZLE_IDENTITY) vk_swiz = component; switch (vk_swiz) { case VK_COMPONENT_SWIZZLE_ZERO: - return VK_SWIZZLE_0; + return PIPE_SWIZZLE_0; case VK_COMPONENT_SWIZZLE_ONE: - return VK_SWIZZLE_1; + return PIPE_SWIZZLE_1; case VK_COMPONENT_SWIZZLE_R: case VK_COMPONENT_SWIZZLE_G: case VK_COMPONENT_SWIZZLE_B: case VK_COMPONENT_SWIZZLE_A: - return (enum vk_swizzle)chan[vk_swiz - VK_COMPONENT_SWIZZLE_R]; + return (enum pipe_swizzle)chan[vk_swiz - VK_COMPONENT_SWIZZLE_R]; default: unreachable("Illegal swizzle"); } @@ -256,7 +245,7 @@ radv_swizzle_conv(VkComponentSwizzle component, const unsigned char chan[4], VkC static inline void vk_format_compose_swizzles(const VkComponentMapping *mapping, const unsigned char swz[4], - enum vk_swizzle dst[4]) + enum pipe_swizzle dst[4]) { dst[0] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_R, swz, mapping->r); dst[1] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_G, swz, mapping->g); @@ -280,14 +269,14 @@ static inline bool vk_format_has_depth(const struct vk_format_description *desc) { return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && - desc->swizzle[0] != VK_SWIZZLE_NONE; + desc->swizzle[0] != PIPE_SWIZZLE_NONE; } static inline bool vk_format_has_stencil(const struct vk_format_description *desc) { return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && - desc->swizzle[1] != VK_SWIZZLE_NONE; + desc->swizzle[1] != PIPE_SWIZZLE_NONE; } static inline bool @@ -457,13 +446,13 @@ vk_format_get_component_bits(VkFormat format, } switch (desc->swizzle[component]) { - case VK_SWIZZLE_X: + case PIPE_SWIZZLE_X: return desc->channel[0].size; - case VK_SWIZZLE_Y: + case PIPE_SWIZZLE_Y: return desc->channel[1].size; - case VK_SWIZZLE_Z: + case PIPE_SWIZZLE_Z: return desc->channel[2].size; - case VK_SWIZZLE_W: + case PIPE_SWIZZLE_W: return desc->channel[3].size; default: return 0; diff --git a/src/amd/vulkan/vk_format_table.py b/src/amd/vulkan/vk_format_table.py index 79f51b997b7..e99b676f5c8 100644 --- a/src/amd/vulkan/vk_format_table.py +++ b/src/amd/vulkan/vk_format_table.py @@ -67,13 +67,13 @@ def bool_map(value): swizzle_map = { - SWIZZLE_X: "VK_SWIZZLE_X", - SWIZZLE_Y: "VK_SWIZZLE_Y", - SWIZZLE_Z: "VK_SWIZZLE_Z", - SWIZZLE_W: "VK_SWIZZLE_W", - SWIZZLE_0: "VK_SWIZZLE_0", - SWIZZLE_1: "VK_SWIZZLE_1", - SWIZZLE_NONE: "VK_SWIZZLE_NONE", + SWIZZLE_X: "PIPE_SWIZZLE_X", + SWIZZLE_Y: "PIPE_SWIZZLE_Y", + SWIZZLE_Z: "PIPE_SWIZZLE_Z", + SWIZZLE_W: "PIPE_SWIZZLE_W", + SWIZZLE_0: "PIPE_SWIZZLE_0", + SWIZZLE_1: "PIPE_SWIZZLE_1", + SWIZZLE_NONE: "PIPE_SWIZZLE_NONE", } def print_channels(format, func):