Mesa (main): turnip: Make copy_format() and tu6_plane_format() return pipe_format
GitLab Mirror
gitlab-mirror at kemper.freedesktop.org
Thu Oct 21 09:15:40 UTC 2021
Module: Mesa
Branch: main
Commit: 9202e8cbafc70d989e4db45a895c36801c30e217
URL: http://cgit.freedesktop.org/mesa/mesa/commit/?id=9202e8cbafc70d989e4db45a895c36801c30e217
Author: Emma Anholt <emma at anholt.net>
Date: Tue Oct 5 15:24:31 2021 -0700
turnip: Make copy_format() and tu6_plane_format() return pipe_format
[ Connor: Keep the argument to copy_format() a VkFormat, fold in
plane_format() conversion. ]
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/13379>
---
src/freedreno/vulkan/tu_clear_blit.c | 375 ++++++++++++++++-------------------
src/freedreno/vulkan/tu_image.c | 28 +--
src/freedreno/vulkan/tu_private.h | 2 +-
3 files changed, 192 insertions(+), 213 deletions(-)
diff --git a/src/freedreno/vulkan/tu_clear_blit.c b/src/freedreno/vulkan/tu_clear_blit.c
index 2dd7887e8d2..d1ddfa70c23 100644
--- a/src/freedreno/vulkan/tu_clear_blit.c
+++ b/src/freedreno/vulkan/tu_clear_blit.c
@@ -82,38 +82,38 @@ r2d_coords(struct tu_cs *cs,
}
static void
-r2d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
+r2d_clear_value(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val)
{
uint32_t clear_value[4] = {};
switch (format) {
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D24_UNORM_S8_UINT:
+ case PIPE_FORMAT_Z24_UNORM_S8_UINT:
+ case PIPE_FORMAT_Z24X8_UNORM:
/* cleared as r8g8b8a8_unorm using special format */
clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 24);
clear_value[1] = clear_value[0] >> 8;
clear_value[2] = clear_value[0] >> 16;
clear_value[3] = val->depthStencil.stencil;
break;
- case VK_FORMAT_D16_UNORM:
- case VK_FORMAT_D32_SFLOAT:
+ case PIPE_FORMAT_Z16_UNORM:
+ case PIPE_FORMAT_Z32_FLOAT:
/* R2D_FLOAT32 */
clear_value[0] = fui(val->depthStencil.depth);
break;
- case VK_FORMAT_S8_UINT:
+ case PIPE_FORMAT_S8_UINT:
clear_value[0] = val->depthStencil.stencil;
break;
- case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+ case PIPE_FORMAT_R9G9B9E5_FLOAT:
/* cleared as UINT32 */
clear_value[0] = float3_to_rgb9e5(val->color.float32);
break;
default:
- assert(!vk_format_is_depth_or_stencil(format));
- const struct util_format_description *desc = vk_format_description(format);
- enum a6xx_2d_ifmt ifmt = format_to_ifmt(tu_vk_format_to_pipe_format(format));
+ assert(!util_format_is_depth_or_stencil(format));
+ const struct util_format_description *desc = util_format_description(format);
+ enum a6xx_2d_ifmt ifmt = format_to_ifmt(format);
assert(desc && (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN ||
- format == VK_FORMAT_B10G11R11_UFLOAT_PACK32));
+ format == PIPE_FORMAT_R11G11B10_FLOAT));
for (unsigned i = 0; i < desc->nr_channels; i++) {
const struct util_format_channel_description *ch = &desc->channel[i];
@@ -179,17 +179,17 @@ r2d_src_stencil(struct tu_cmd_buffer *cmd,
static void
r2d_src_buffer(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
uint64_t va, uint32_t pitch,
uint32_t width, uint32_t height)
{
- struct tu_native_format format = tu6_format_texture(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+ struct tu_native_format fmt = tu6_format_texture(format, TILE6_LINEAR);
tu_cs_emit_regs(cs,
A6XX_SP_PS_2D_SRC_INFO(
- .color_format = format.fmt,
- .color_swap = format.swap,
- .srgb = vk_format_is_srgb(vk_format),
+ .color_format = fmt.fmt,
+ .color_swap = fmt.swap,
+ .srgb = util_format_is_srgb(format),
.unk20 = 1,
.unk22 = 1),
A6XX_SP_PS_2D_SRC_SIZE(.width = width, .height = height),
@@ -218,15 +218,15 @@ r2d_dst_stencil(struct tu_cs *cs, const struct tu_image_view *iview, uint32_t la
}
static void
-r2d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch)
+r2d_dst_buffer(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch)
{
- struct tu_native_format format = tu6_format_color(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+ struct tu_native_format fmt = tu6_format_color(format, TILE6_LINEAR);
tu_cs_emit_regs(cs,
A6XX_RB_2D_DST_INFO(
- .color_format = format.fmt,
- .color_swap = format.swap,
- .srgb = vk_format_is_srgb(vk_format)),
+ .color_format = fmt.fmt,
+ .color_swap = fmt.swap,
+ .srgb = util_format_is_srgb(format)),
A6XX_RB_2D_DST(.qword = va),
A6XX_RB_2D_DST_PITCH(pitch));
}
@@ -234,25 +234,25 @@ r2d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch
static void
r2d_setup_common(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
VkImageAspectFlags aspect_mask,
unsigned blit_param,
bool clear,
bool ubwc,
bool scissor)
{
- enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
enum a6xx_format fmt = tu6_base_format(format);
enum a6xx_2d_ifmt ifmt = format_to_ifmt(format);
+
uint32_t unknown_8c01 = 0;
- if ((vk_format == VK_FORMAT_D24_UNORM_S8_UINT ||
- vk_format == VK_FORMAT_X8_D24_UNORM_PACK32) && ubwc) {
+ if ((format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+ format == PIPE_FORMAT_Z24X8_UNORM) && ubwc) {
fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
}
/* note: the only format with partial clearing is D24S8 */
- if (vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+ if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT) {
/* preserve stencil channel */
if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT)
unknown_8c01 = 0x08000041;
@@ -271,7 +271,7 @@ r2d_setup_common(struct tu_cmd_buffer *cmd,
.d24s8 = fmt == FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8 && !clear,
.color_format = fmt,
.mask = 0xf,
- .ifmt = vk_format_is_srgb(vk_format) ? R2D_UNORM8_SRGB : ifmt,
+ .ifmt = util_format_is_srgb(format) ? R2D_UNORM8_SRGB : ifmt,
).value;
tu_cs_emit_pkt4(cs, REG_A6XX_RB_2D_BLIT_CNTL, 1);
@@ -284,17 +284,17 @@ r2d_setup_common(struct tu_cmd_buffer *cmd,
fmt = FMT6_16_16_16_16_FLOAT;
tu_cs_emit_regs(cs, A6XX_SP_2D_DST_FORMAT(
- .sint = vk_format_is_sint(vk_format),
- .uint = vk_format_is_uint(vk_format),
+ .sint = util_format_is_pure_sint(format),
+ .uint = util_format_is_pure_uint(format),
.color_format = fmt,
- .srgb = vk_format_is_srgb(vk_format),
+ .srgb = util_format_is_srgb(format),
.mask = 0xf));
}
static void
r2d_setup(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
VkImageAspectFlags aspect_mask,
unsigned blit_param,
bool clear,
@@ -305,7 +305,7 @@ r2d_setup(struct tu_cmd_buffer *cmd,
tu_emit_cache_flush_ccu(cmd, cs, TU_CMD_CCU_SYSMEM);
- r2d_setup_common(cmd, cs, vk_format, aspect_mask, blit_param, clear, ubwc, false);
+ r2d_setup_common(cmd, cs, format, aspect_mask, blit_param, clear, ubwc, false);
}
static void
@@ -750,7 +750,7 @@ r3d_coords(struct tu_cs *cs,
}
static void
-r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
+r3d_clear_value(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val)
{
tu_cs_emit_pkt7(cs, CP_LOAD_STATE6_FRAG, 3 + 4);
tu_cs_emit(cs, CP_LOAD_STATE6_0_DST_OFF(0) |
@@ -761,8 +761,8 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
tu_cs_emit(cs, CP_LOAD_STATE6_1_EXT_SRC_ADDR(0));
tu_cs_emit(cs, CP_LOAD_STATE6_2_EXT_SRC_ADDR_HI(0));
switch (format) {
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D24_UNORM_S8_UINT: {
+ case PIPE_FORMAT_Z24X8_UNORM:
+ case PIPE_FORMAT_Z24_UNORM_S8_UINT: {
/* cleared as r8g8b8a8_unorm using special format */
uint32_t tmp = tu_pack_float32_for_unorm(val->depthStencil.depth, 24);
tu_cs_emit(cs, fui((tmp & 0xff) / 255.0f));
@@ -770,14 +770,14 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
tu_cs_emit(cs, fui((tmp >> 16 & 0xff) / 255.0f));
tu_cs_emit(cs, fui((val->depthStencil.stencil & 0xff) / 255.0f));
} break;
- case VK_FORMAT_D16_UNORM:
- case VK_FORMAT_D32_SFLOAT:
+ case PIPE_FORMAT_Z16_UNORM:
+ case PIPE_FORMAT_Z32_FLOAT:
tu_cs_emit(cs, fui(val->depthStencil.depth));
tu_cs_emit(cs, 0);
tu_cs_emit(cs, 0);
tu_cs_emit(cs, 0);
break;
- case VK_FORMAT_S8_UINT:
+ case PIPE_FORMAT_S8_UINT:
tu_cs_emit(cs, val->depthStencil.stencil & 0xff);
tu_cs_emit(cs, 0);
tu_cs_emit(cs, 0);
@@ -785,7 +785,7 @@ r3d_clear_value(struct tu_cs *cs, VkFormat format, const VkClearValue *val)
break;
default:
/* as color formats use clear value as-is */
- assert(!vk_format_is_depth_or_stencil(format));
+ assert(!util_format_is_depth_or_stencil(format));
tu_cs_emit_array(cs, val->color.uint32, 4);
break;
}
@@ -868,23 +868,23 @@ r3d_src(struct tu_cmd_buffer *cmd,
static void
r3d_src_buffer(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
uint64_t va, uint32_t pitch,
uint32_t width, uint32_t height)
{
uint32_t desc[A6XX_TEX_CONST_DWORDS];
- struct tu_native_format format = tu6_format_texture(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+ struct tu_native_format fmt = tu6_format_texture(format, TILE6_LINEAR);
desc[0] =
- COND(vk_format_is_srgb(vk_format), A6XX_TEX_CONST_0_SRGB) |
- A6XX_TEX_CONST_0_FMT(format.fmt) |
- A6XX_TEX_CONST_0_SWAP(format.swap) |
+ COND(util_format_is_srgb(format), A6XX_TEX_CONST_0_SRGB) |
+ A6XX_TEX_CONST_0_FMT(fmt.fmt) |
+ A6XX_TEX_CONST_0_SWAP(fmt.swap) |
A6XX_TEX_CONST_0_SWIZ_X(A6XX_TEX_X) |
// XXX to swizzle into .w for stencil buffer_to_image
- A6XX_TEX_CONST_0_SWIZ_Y(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Y) |
- A6XX_TEX_CONST_0_SWIZ_Z(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Z) |
- A6XX_TEX_CONST_0_SWIZ_W(vk_format == VK_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_W);
+ A6XX_TEX_CONST_0_SWIZ_Y(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Y) |
+ A6XX_TEX_CONST_0_SWIZ_Z(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_Z) |
+ A6XX_TEX_CONST_0_SWIZ_W(format == PIPE_FORMAT_R8_UNORM ? A6XX_TEX_X : A6XX_TEX_W);
desc[1] = A6XX_TEX_CONST_1_WIDTH(width) | A6XX_TEX_CONST_1_HEIGHT(height);
desc[2] =
A6XX_TEX_CONST_2_PITCH(pitch) |
@@ -902,7 +902,7 @@ static void
r3d_src_gmem(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
const struct tu_image_view *iview,
- VkFormat format,
+ enum pipe_format format,
uint32_t gmem_offset,
uint32_t cpp)
{
@@ -911,7 +911,7 @@ r3d_src_gmem(struct tu_cmd_buffer *cmd,
/* patch the format so that depth/stencil get the right format */
desc[0] &= ~A6XX_TEX_CONST_0_FMT__MASK;
- desc[0] |= A6XX_TEX_CONST_0_FMT(tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_2).fmt);
+ desc[0] |= A6XX_TEX_CONST_0_FMT(tu6_format_texture(format, TILE6_2).fmt);
/* patched for gmem */
desc[0] &= ~(A6XX_TEX_CONST_0_SWAP__MASK | A6XX_TEX_CONST_0_TILE_MODE__MASK);
@@ -954,12 +954,12 @@ r3d_dst_stencil(struct tu_cs *cs, const struct tu_image_view *iview, uint32_t la
}
static void
-r3d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch)
+r3d_dst_buffer(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch)
{
- struct tu_native_format format = tu6_format_color(tu_vk_format_to_pipe_format(vk_format), TILE6_LINEAR);
+ struct tu_native_format fmt = tu6_format_color(format, TILE6_LINEAR);
tu_cs_emit_regs(cs,
- A6XX_RB_MRT_BUF_INFO(0, .color_format = format.fmt, .color_swap = format.swap),
+ A6XX_RB_MRT_BUF_INFO(0, .color_format = fmt.fmt, .color_swap = fmt.swap),
A6XX_RB_MRT_PITCH(0, pitch),
A6XX_RB_MRT_ARRAY_PITCH(0, 0),
A6XX_RB_MRT_BASE(0, .qword = va),
@@ -969,14 +969,14 @@ r3d_dst_buffer(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch
}
static uint8_t
-aspect_write_mask(VkFormat vk_format, VkImageAspectFlags aspect_mask)
+aspect_write_mask(enum pipe_format format, VkImageAspectFlags aspect_mask)
{
uint8_t mask = 0xf;
assert(aspect_mask);
/* note: the only format with partial writing is D24S8,
* clear/blit uses the _AS_R8G8B8A8 format to access it
*/
- if (vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
+ if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT) {
if (aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT)
mask = 0x7;
if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT)
@@ -988,18 +988,18 @@ aspect_write_mask(VkFormat vk_format, VkImageAspectFlags aspect_mask)
static void
r3d_setup(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
VkImageAspectFlags aspect_mask,
unsigned blit_param,
bool clear,
bool ubwc,
VkSampleCountFlagBits samples)
{
- enum a6xx_format format = tu6_base_format(tu_vk_format_to_pipe_format(vk_format));
+ enum a6xx_format fmt = tu6_base_format(format);
- if ((vk_format == VK_FORMAT_D24_UNORM_S8_UINT ||
- vk_format == VK_FORMAT_X8_D24_UNORM_PACK32) && ubwc) {
- format = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
+ if ((format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+ format == PIPE_FORMAT_Z24X8_UNORM) && ubwc) {
+ fmt = FMT6_Z24_UNORM_S8_UINT_AS_R8G8B8A8;
}
if (!cmd->state.pass) {
@@ -1037,14 +1037,14 @@ r3d_setup(struct tu_cmd_buffer *cmd,
tu_cs_emit_regs(cs, A6XX_SP_FS_RENDER_COMPONENTS(.rt0 = 0xf));
tu_cs_emit_regs(cs, A6XX_SP_FS_MRT_REG(0,
- .color_format = format,
- .color_sint = vk_format_is_sint(vk_format),
- .color_uint = vk_format_is_uint(vk_format)));
+ .color_format = fmt,
+ .color_sint = util_format_is_pure_sint(format),
+ .color_uint = util_format_is_pure_uint(format)));
tu_cs_emit_regs(cs, A6XX_RB_MRT_CONTROL(0,
- .component_enable = aspect_write_mask(vk_format, aspect_mask)));
- tu_cs_emit_regs(cs, A6XX_RB_SRGB_CNTL(vk_format_is_srgb(vk_format)));
- tu_cs_emit_regs(cs, A6XX_SP_SRGB_CNTL(vk_format_is_srgb(vk_format)));
+ .component_enable = aspect_write_mask(format, aspect_mask)));
+ tu_cs_emit_regs(cs, A6XX_RB_SRGB_CNTL(util_format_is_srgb(format)));
+ tu_cs_emit_regs(cs, A6XX_SP_SRGB_CNTL(util_format_is_srgb(format)));
tu_cs_emit_regs(cs, A6XX_GRAS_LRZ_CNTL(0));
tu_cs_emit_regs(cs, A6XX_RB_LRZ_CNTL(0));
@@ -1085,7 +1085,7 @@ struct blit_ops {
const VkOffset2D *dst,
const VkOffset2D *src,
const VkExtent2D *extent);
- void (*clear_value)(struct tu_cs *cs, VkFormat format, const VkClearValue *val);
+ void (*clear_value)(struct tu_cs *cs, enum pipe_format format, const VkClearValue *val);
void (*src)(
struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
@@ -1093,14 +1093,14 @@ struct blit_ops {
uint32_t layer,
VkFilter filter);
void (*src_buffer)(struct tu_cmd_buffer *cmd, struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
uint64_t va, uint32_t pitch,
uint32_t width, uint32_t height);
void (*dst)(struct tu_cs *cs, const struct fdl6_view *iview, uint32_t layer);
- void (*dst_buffer)(struct tu_cs *cs, VkFormat vk_format, uint64_t va, uint32_t pitch);
+ void (*dst_buffer)(struct tu_cs *cs, enum pipe_format format, uint64_t va, uint32_t pitch);
void (*setup)(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat vk_format,
+ enum pipe_format format,
VkImageAspectFlags aspect_mask,
unsigned blit_param, /* CmdBlitImage: rotation in 2D path and z scaling in 3D path */
bool clear,
@@ -1151,76 +1151,53 @@ coords(const struct blit_ops *ops,
* compression behavior, so no just returning R8_UINT/R16_UINT/R32_UINT for
* everything.
*/
-static VkFormat
-copy_format(VkFormat format, VkImageAspectFlags aspect_mask, bool copy_buffer)
-{
- if (vk_format_is_compressed(format)) {
- switch (vk_format_get_blocksize(format)) {
- case 1: return VK_FORMAT_R8_UINT;
- case 2: return VK_FORMAT_R16_UINT;
- case 4: return VK_FORMAT_R32_UINT;
- case 8: return VK_FORMAT_R32G32_UINT;
- case 16:return VK_FORMAT_R32G32B32A32_UINT;
+static enum pipe_format
+copy_format(VkFormat vk_format, VkImageAspectFlags aspect_mask, bool copy_buffer)
+{
+ if (vk_format_is_compressed(vk_format)) {
+ switch (vk_format_get_blocksize(vk_format)) {
+ case 1: return PIPE_FORMAT_R8_UINT;
+ case 2: return PIPE_FORMAT_R16_UINT;
+ case 4: return PIPE_FORMAT_R32_UINT;
+ case 8: return PIPE_FORMAT_R32G32_UINT;
+ case 16:return PIPE_FORMAT_R32G32B32A32_UINT;
default:
unreachable("unhandled format size");
}
}
- switch (format) {
+ enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
+
/* For SNORM formats, copy them as the equivalent UNORM format. If we treat
* them as snorm then the 0x80 (-1.0 snorm8) value will get clamped to 0x81
* (also -1.0), when we're supposed to be memcpying the bits. See
* https://gitlab.khronos.org/Tracker/vk-gl-cts/-/issues/2917 for discussion.
*/
- case VK_FORMAT_R8_SNORM:
- return VK_FORMAT_R8_UNORM;
- case VK_FORMAT_R8G8_SNORM:
- return VK_FORMAT_R8G8_UNORM;
- case VK_FORMAT_R8G8B8_SNORM:
- return VK_FORMAT_R8G8B8_UNORM;
- case VK_FORMAT_B8G8R8_SNORM:
- return VK_FORMAT_B8G8R8_UNORM;
- case VK_FORMAT_R8G8B8A8_SNORM:
- return VK_FORMAT_R8G8B8A8_UNORM;
- case VK_FORMAT_B8G8R8A8_SNORM:
- return VK_FORMAT_B8G8R8A8_UNORM;
- case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
- return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
- case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
- return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
- case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
- return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
- case VK_FORMAT_R16_SNORM:
- return VK_FORMAT_R16_UNORM;
- case VK_FORMAT_R16G16_SNORM:
- return VK_FORMAT_R16G16_UNORM;
- case VK_FORMAT_R16G16B16_SNORM:
- return VK_FORMAT_R16G16B16_UNORM;
- case VK_FORMAT_R16G16B16A16_SNORM:
- return VK_FORMAT_R16G16B16A16_UNORM;
-
- case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
- return VK_FORMAT_R32_UINT;
-
- case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ format = util_format_snorm_to_unorm(format);
+
+ switch (format) {
+ case PIPE_FORMAT_R9G9B9E5_FLOAT:
+ return PIPE_FORMAT_R32_UINT;
+
+ case PIPE_FORMAT_R8_G8B8_420_UNORM:
if (aspect_mask == VK_IMAGE_ASPECT_PLANE_1_BIT)
- return VK_FORMAT_R8G8_UNORM;
+ return PIPE_FORMAT_R8G8_UNORM;
else
- return VK_FORMAT_R8_UNORM;
- case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
- return VK_FORMAT_R8_UNORM;
+ return PIPE_FORMAT_R8_UNORM;
+ case PIPE_FORMAT_R8_G8_B8_420_UNORM:
+ return PIPE_FORMAT_R8_UNORM;
- case VK_FORMAT_D24_UNORM_S8_UINT:
+ case PIPE_FORMAT_Z24_UNORM_S8_UINT:
if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT && copy_buffer)
- return VK_FORMAT_R8_UNORM;
+ return PIPE_FORMAT_R8_UNORM;
else
return format;
- case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
if (aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT)
- return VK_FORMAT_S8_UINT;
+ return PIPE_FORMAT_S8_UINT;
assert(aspect_mask == VK_IMAGE_ASPECT_DEPTH_BIT);
- return VK_FORMAT_D32_SFLOAT;
+ return PIPE_FORMAT_Z32_FLOAT;
default:
return format;
@@ -1235,10 +1212,10 @@ tu6_clear_lrz(struct tu_cmd_buffer *cmd,
{
const struct blit_ops *ops = &r2d_ops;
- ops->setup(cmd, cs, VK_FORMAT_D16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT, 0, true, false,
+ ops->setup(cmd, cs, PIPE_FORMAT_Z16_UNORM, VK_IMAGE_ASPECT_DEPTH_BIT, 0, true, false,
VK_SAMPLE_COUNT_1_BIT);
- ops->clear_value(cs, VK_FORMAT_D16_UNORM, value);
- ops->dst_buffer(cs, VK_FORMAT_D16_UNORM,
+ ops->clear_value(cs, PIPE_FORMAT_Z16_UNORM, value);
+ ops->dst_buffer(cs, PIPE_FORMAT_Z16_UNORM,
image->bo->iova + image->bo_offset + image->lrz_offset,
image->lrz_pitch * 2);
ops->coords(cs, &(VkOffset2D) {}, NULL, &(VkExtent2D) {image->lrz_pitch, image->lrz_height});
@@ -1249,7 +1226,7 @@ tu6_clear_lrz(struct tu_cmd_buffer *cmd,
static void
tu_image_view_copy_blit(struct fdl6_view *iview,
struct tu_image *image,
- VkFormat format,
+ enum pipe_format format,
const VkImageSubresourceLayers *subres,
uint32_t layer,
bool stencil_read,
@@ -1258,8 +1235,8 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
VkImageAspectFlags aspect_mask = subres->aspectMask;
/* always use the AS_R8G8B8A8 format for these */
- if (format == VK_FORMAT_D24_UNORM_S8_UINT ||
- format == VK_FORMAT_X8_D24_UNORM_PACK32) {
+ if (format == PIPE_FORMAT_Z24_UNORM_S8_UINT ||
+ format == PIPE_FORMAT_Z24X8_UNORM) {
aspect_mask = VK_IMAGE_ASPECT_COLOR_BIT;
}
@@ -1272,8 +1249,7 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
.layer_count = 1,
.base_miplevel = subres->mipLevel,
.level_count = 1,
- .format = tu_format_for_aspect(tu_vk_format_to_pipe_format(format),
- aspect_mask),
+ .format = tu_format_for_aspect(format, aspect_mask),
.swiz = {
/* image_to_buffer from d24s8 with stencil aspect mask writes out to r8 */
stencil_read ? PIPE_SWIZZLE_W : PIPE_SWIZZLE_X,
@@ -1286,7 +1262,7 @@ tu_image_view_copy_blit(struct fdl6_view *iview,
static void
tu_image_view_copy(struct fdl6_view *iview,
struct tu_image *image,
- VkFormat format,
+ enum pipe_format format,
const VkImageSubresourceLayers *subres,
uint32_t layer,
bool stencil_read)
@@ -1300,7 +1276,7 @@ tu_image_view_blit(struct fdl6_view *iview,
const VkImageSubresourceLayers *subres,
uint32_t layer)
{
- VkFormat format =
+ enum pipe_format format =
tu6_plane_format(image->vk_format, tu6_plane_index(image->vk_format,
subres->aspectMask));
tu_image_view_copy_blit(iview, image, format, subres, layer, false, false);
@@ -1382,7 +1358,7 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
trace_start_blit(&cmd->trace, cs);
- ops->setup(cmd, cs, format, info->dstSubresource.aspectMask,
+ ops->setup(cmd, cs, tu_vk_format_to_pipe_format(format), info->dstSubresource.aspectMask,
blit_param, false, dst_image->layout[0].ubwc,
dst_image->layout[0].nr_samples);
@@ -1411,7 +1387,7 @@ tu6_blit_image(struct tu_cmd_buffer *cmd,
MIN2(info->dstOffsets[0].z, info->dstOffsets[1].z));
if (z_scale) {
- VkFormat src_format =
+ enum pipe_format src_format =
tu6_plane_format(src_image->vk_format,
tu6_plane_index(src_image->vk_format,
info->srcSubresource.aspectMask));
@@ -1509,8 +1485,10 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
{
struct tu_cs *cs = &cmd->cs;
uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
- VkFormat src_format =
+ enum pipe_format src_format =
copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, true);
+ enum pipe_format dst_format =
+ copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false);
const struct blit_ops *ops = &r2d_ops;
/* special case for buffer to stencil */
@@ -1530,17 +1508,14 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
copy_compressed(dst_image->vk_format, &offset, &extent, &src_width, &src_height);
- uint32_t pitch = src_width * vk_format_get_blocksize(src_format);
+ uint32_t pitch = src_width * util_format_get_blocksize(src_format);
uint32_t layer_size = src_height * pitch;
- ops->setup(cmd, cs,
- copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false),
+ ops->setup(cmd, cs, dst_format,
info->imageSubresource.aspectMask, 0, false, dst_image->layout[0].ubwc,
dst_image->layout[0].nr_samples);
struct fdl6_view dst;
- VkFormat dst_format =
- copy_format(dst_image->vk_format, info->imageSubresource.aspectMask, false);
tu_image_view_copy(&dst, dst_image, dst_format, &info->imageSubresource, offset.z, false);
for (uint32_t i = 0; i < layers; i++) {
@@ -1549,7 +1524,7 @@ tu_copy_buffer_to_image(struct tu_cmd_buffer *cmd,
uint64_t src_va = tu_buffer_iova(src_buffer) + info->bufferOffset + layer_size * i;
if ((src_va & 63) || (pitch & 63)) {
for (uint32_t y = 0; y < extent.height; y++) {
- uint32_t x = (src_va & 63) / vk_format_get_blocksize(src_format);
+ uint32_t x = (src_va & 63) / util_format_get_blocksize(src_format);
ops->src_buffer(cmd, cs, src_format, src_va & ~63, pitch,
x + extent.width, 1);
ops->coords(cs, &(VkOffset2D){offset.x, offset.y + y}, &(VkOffset2D){x},
@@ -1591,8 +1566,10 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
{
struct tu_cs *cs = &cmd->cs;
uint32_t layers = MAX2(info->imageExtent.depth, info->imageSubresource.layerCount);
- VkFormat dst_format =
+ enum pipe_format dst_format =
copy_format(src_image->vk_format, info->imageSubresource.aspectMask, true);
+ enum pipe_format src_format =
+ copy_format(src_image->vk_format, info->imageSubresource.aspectMask, false);
bool stencil_read = false;
if (src_image->vk_format == VK_FORMAT_D24_UNORM_S8_UINT &&
@@ -1608,15 +1585,13 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
copy_compressed(src_image->vk_format, &offset, &extent, &dst_width, &dst_height);
- uint32_t pitch = dst_width * vk_format_get_blocksize(dst_format);
+ uint32_t pitch = dst_width * util_format_get_blocksize(dst_format);
uint32_t layer_size = pitch * dst_height;
ops->setup(cmd, cs, dst_format, VK_IMAGE_ASPECT_COLOR_BIT, 0, false, false,
VK_SAMPLE_COUNT_1_BIT);
struct fdl6_view src;
- VkFormat src_format =
- copy_format(src_image->vk_format, info->imageSubresource.aspectMask, false);
tu_image_view_copy(&src, src_image, src_format, &info->imageSubresource, offset.z, stencil_read);
for (uint32_t i = 0; i < layers; i++) {
@@ -1625,7 +1600,7 @@ tu_copy_image_to_buffer(struct tu_cmd_buffer *cmd,
uint64_t dst_va = tu_buffer_iova(dst_buffer) + info->bufferOffset + layer_size * i;
if ((dst_va & 63) || (pitch & 63)) {
for (uint32_t y = 0; y < extent.height; y++) {
- uint32_t x = (dst_va & 63) / vk_format_get_blocksize(dst_format);
+ uint32_t x = (dst_va & 63) / util_format_get_blocksize(dst_format);
ops->dst_buffer(cs, dst_format, dst_va & ~63, 0);
ops->coords(cs, &(VkOffset2D) {x}, &(VkOffset2D){offset.x, offset.y + y},
&(VkExtent2D) {extent.width, 1});
@@ -1669,10 +1644,10 @@ tu_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer,
*/
static bool
-is_swapped_format(VkFormat format)
+is_swapped_format(enum pipe_format format)
{
- struct tu_native_format linear = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_LINEAR);
- struct tu_native_format tiled = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_3);
+ struct tu_native_format linear = tu6_format_texture(format, TILE6_LINEAR);
+ struct tu_native_format tiled = tu6_format_texture(format, TILE6_3);
return linear.fmt != tiled.fmt || linear.swap != tiled.swap;
}
@@ -1699,7 +1674,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
if (dst_image->layout[0].nr_samples > 1)
ops = &r3d_ops;
- VkFormat format = VK_FORMAT_UNDEFINED;
+ enum pipe_format format = PIPE_FORMAT_NONE;
VkOffset3D src_offset = info->srcOffset;
VkOffset3D dst_offset = info->dstOffset;
VkExtent3D extent = info->extent;
@@ -1724,8 +1699,8 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
copy_compressed(src_image->vk_format, &src_offset, &extent, NULL, NULL);
copy_compressed(dst_image->vk_format, &dst_offset, NULL, NULL, NULL);
- VkFormat dst_format = copy_format(dst_image->vk_format, info->dstSubresource.aspectMask, false);
- VkFormat src_format = copy_format(src_image->vk_format, info->srcSubresource.aspectMask, false);
+ enum pipe_format dst_format = copy_format(dst_image->vk_format, info->dstSubresource.aspectMask, false);
+ enum pipe_format src_format = copy_format(src_image->vk_format, info->srcSubresource.aspectMask, false);
bool use_staging_blit = false;
@@ -1776,7 +1751,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
staging_layout.ubwc = false;
fdl6_layout(&staging_layout,
- vk_format_to_pipe_format(src_format),
+ src_format,
src_image->layout[0].nr_samples,
extent.width,
extent.height,
@@ -1803,8 +1778,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
.layer_count = 1,
.base_miplevel = 0,
.level_count = info->srcSubresource.layerCount,
- .format = tu_format_for_aspect(vk_format_to_pipe_format(src_format),
- VK_IMAGE_ASPECT_COLOR_BIT),
+ .format = tu_format_for_aspect(src_format, VK_IMAGE_ASPECT_COLOR_BIT),
.swiz = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W },
.type = FDL_VIEW_TYPE_2D,
}, false);
@@ -1832,8 +1806,7 @@ tu_copy_image_to_image(struct tu_cmd_buffer *cmd,
.layer_count = 1,
.base_miplevel = 0,
.level_count = info->srcSubresource.layerCount,
- .format = tu_format_for_aspect(vk_format_to_pipe_format(dst_format),
- VK_IMAGE_ASPECT_COLOR_BIT),
+ .format = tu_format_for_aspect(dst_format, VK_IMAGE_ASPECT_COLOR_BIT),
.swiz = { PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y, PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W },
.type = FDL_VIEW_TYPE_2D,
}, false);
@@ -1904,7 +1877,7 @@ copy_buffer(struct tu_cmd_buffer *cmd,
{
const struct blit_ops *ops = &r2d_ops;
struct tu_cs *cs = &cmd->cs;
- VkFormat format = block_size == 4 ? VK_FORMAT_R32_UINT : VK_FORMAT_R8_UNORM;
+ enum pipe_format format = block_size == 4 ? PIPE_FORMAT_R32_UINT : PIPE_FORMAT_R8_UNORM;
uint64_t blocks = size / block_size;
ops->setup(cmd, cs, format, VK_IMAGE_ASPECT_COLOR_BIT, 0, false, false,
@@ -1986,15 +1959,15 @@ tu_CmdFillBuffer(VkCommandBuffer commandBuffer,
uint64_t dst_va = tu_buffer_iova(buffer) + dstOffset;
uint32_t blocks = fillSize / 4;
- ops->setup(cmd, cs, VK_FORMAT_R32_UINT, VK_IMAGE_ASPECT_COLOR_BIT, 0, true, false,
+ ops->setup(cmd, cs, PIPE_FORMAT_R32_UINT, VK_IMAGE_ASPECT_COLOR_BIT, 0, true, false,
VK_SAMPLE_COUNT_1_BIT);
- ops->clear_value(cs, VK_FORMAT_R32_UINT, &(VkClearValue){.color = {.uint32[0] = data}});
+ ops->clear_value(cs, PIPE_FORMAT_R32_UINT, &(VkClearValue){.color = {.uint32[0] = data}});
while (blocks) {
uint32_t dst_x = (dst_va & 63) / 4;
uint32_t width = MIN2(blocks, 0x4000 - dst_x);
- ops->dst_buffer(cs, VK_FORMAT_R32_UINT, dst_va & ~63, 0);
+ ops->dst_buffer(cs, PIPE_FORMAT_R32_UINT, dst_va & ~63, 0);
ops->coords(cs, &(VkOffset2D) {dst_x}, NULL, &(VkExtent2D) {width, 1});
ops->run(cmd, cs);
@@ -2020,8 +1993,9 @@ tu_CmdResolveImage(VkCommandBuffer commandBuffer,
const struct blit_ops *ops = &r2d_ops;
struct tu_cs *cs = &cmd->cs;
- ops->setup(cmd, cs, dst_image->vk_format, VK_IMAGE_ASPECT_COLOR_BIT,
- 0, false, dst_image->layout[0].ubwc, VK_SAMPLE_COUNT_1_BIT);
+ ops->setup(cmd, cs, tu_vk_format_to_pipe_format(dst_image->vk_format),
+ VK_IMAGE_ASPECT_COLOR_BIT, 0, false, dst_image->layout[0].ubwc,
+ VK_SAMPLE_COUNT_1_BIT);
for (uint32_t i = 0; i < regionCount; ++i) {
const VkImageResolve *info = &pRegions[i];
@@ -2067,8 +2041,9 @@ resolve_sysmem(struct tu_cmd_buffer *cmd,
trace_start_sysmem_resolve(&cmd->trace, cs);
- ops->setup(cmd, cs, format, VK_IMAGE_ASPECT_COLOR_BIT,
- 0, false, dst->view.ubwc_enabled, VK_SAMPLE_COUNT_1_BIT);
+ ops->setup(cmd, cs, tu_vk_format_to_pipe_format(format),
+ VK_IMAGE_ASPECT_COLOR_BIT, 0, false, dst->view.ubwc_enabled,
+ VK_SAMPLE_COUNT_1_BIT);
ops->coords(cs, &rect->offset, &rect->offset, &rect->extent);
for_each_layer(i, layer_mask, layers) {
@@ -2119,9 +2094,9 @@ clear_image(struct tu_cmd_buffer *cmd,
uint32_t level_count = tu_get_levelCount(image, range);
uint32_t layer_count = tu_get_layerCount(image, range);
struct tu_cs *cs = &cmd->cs;
- VkFormat format;
+ enum pipe_format format;
if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
- format = VK_FORMAT_R32_UINT;
+ format = PIPE_FORMAT_R32_UINT;
} else {
format = tu6_plane_format(image->vk_format,
tu6_plane_index(image->vk_format,
@@ -2138,7 +2113,7 @@ clear_image(struct tu_cmd_buffer *cmd,
ops->setup(cmd, cs, format, aspect_mask, 0, true, image->layout[0].ubwc,
image->layout[0].nr_samples);
if (image->vk_format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
- ops->clear_value(cs, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, clear_value);
+ ops->clear_value(cs, PIPE_FORMAT_R9G9B9E5_FLOAT, clear_value);
else
ops->clear_value(cs, format, clear_value);
@@ -2364,21 +2339,21 @@ tu_clear_sysmem_attachments(struct tu_cmd_buffer *cmd,
}
static void
-pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_value[4])
+pack_gmem_clear_value(const VkClearValue *val, enum pipe_format format, uint32_t clear_value[4])
{
switch (format) {
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D24_UNORM_S8_UINT:
+ case PIPE_FORMAT_Z24X8_UNORM:
+ case PIPE_FORMAT_Z24_UNORM_S8_UINT:
clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 24) |
val->depthStencil.stencil << 24;
return;
- case VK_FORMAT_D16_UNORM:
+ case PIPE_FORMAT_Z16_UNORM:
clear_value[0] = tu_pack_float32_for_unorm(val->depthStencil.depth, 16);
return;
- case VK_FORMAT_D32_SFLOAT:
+ case PIPE_FORMAT_Z32_FLOAT:
clear_value[0] = fui(val->depthStencil.depth);
return;
- case VK_FORMAT_S8_UINT:
+ case PIPE_FORMAT_S8_UINT:
clear_value[0] = val->depthStencil.stencil;
return;
default:
@@ -2387,33 +2362,33 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
float tmp[4];
memcpy(tmp, val->color.float32, 4 * sizeof(float));
- if (vk_format_is_srgb(format)) {
+ if (util_format_is_srgb(format)) {
for (int i = 0; i < 3; i++)
tmp[i] = util_format_linear_to_srgb_float(tmp[i]);
}
#define PACK_F(type) util_format_##type##_pack_rgba_float \
( (uint8_t*) &clear_value[0], 0, tmp, 0, 1, 1)
- switch (vk_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_X)) {
+ switch (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_X)) {
case 4:
PACK_F(r4g4b4a4_unorm);
break;
case 5:
- if (vk_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_Y) == 6)
+ if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, PIPE_SWIZZLE_Y) == 6)
PACK_F(r5g6b5_unorm);
else
PACK_F(r5g5b5a1_unorm);
break;
case 8:
- if (vk_format_is_snorm(format))
+ if (util_format_is_snorm(format))
PACK_F(r8g8b8a8_snorm);
- else if (vk_format_is_unorm(format))
+ else if (util_format_is_unorm(format))
PACK_F(r8g8b8a8_unorm);
else
pack_int8(clear_value, val->color.uint32);
break;
case 10:
- if (vk_format_is_int(format))
+ if (util_format_is_pure_integer(format))
pack_int10_2(clear_value, val->color.uint32);
else
PACK_F(r10g10b10a2_unorm);
@@ -2422,11 +2397,11 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
clear_value[0] = float3_to_r11g11b10f(val->color.float32);
break;
case 16:
- if (vk_format_is_snorm(format))
+ if (util_format_is_snorm(format))
PACK_F(r16g16b16a16_snorm);
- else if (vk_format_is_unorm(format))
+ else if (util_format_is_unorm(format))
PACK_F(r16g16b16a16_unorm);
- else if (vk_format_is_float(format))
+ else if (util_format_is_float(format))
PACK_F(r16g16b16a16_float);
else
pack_int16(clear_value, val->color.uint32);
@@ -2443,13 +2418,13 @@ pack_gmem_clear_value(const VkClearValue *val, VkFormat format, uint32_t clear_v
static void
clear_gmem_attachment(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat format,
+ enum pipe_format format,
uint8_t clear_mask,
uint32_t gmem_offset,
const VkClearValue *value)
{
tu_cs_emit_pkt4(cs, REG_A6XX_RB_BLIT_DST_INFO, 1);
- tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(tu6_base_format(tu_vk_format_to_pipe_format(format))));
+ tu_cs_emit(cs, A6XX_RB_BLIT_DST_INFO_COLOR_FORMAT(tu6_base_format(format)));
tu_cs_emit_regs(cs, A6XX_RB_BLIT_INFO(.gmem = 1, .clear_mask = clear_mask));
@@ -2480,15 +2455,16 @@ tu_emit_clear_gmem_attachment(struct tu_cmd_buffer *cmd,
trace_start_gmem_clear(&cmd->trace, cs);
+ enum pipe_format format = tu_vk_format_to_pipe_format(att->format);
if (att->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
if (mask & VK_IMAGE_ASPECT_DEPTH_BIT)
- clear_gmem_attachment(cmd, cs, VK_FORMAT_D32_SFLOAT, 0xf, att->gmem_offset, value);
+ clear_gmem_attachment(cmd, cs, PIPE_FORMAT_Z32_FLOAT, 0xf, att->gmem_offset, value);
if (mask & VK_IMAGE_ASPECT_STENCIL_BIT)
- clear_gmem_attachment(cmd, cs, VK_FORMAT_S8_UINT, 0xf, att->gmem_offset_stencil, value);
+ clear_gmem_attachment(cmd, cs, PIPE_FORMAT_S8_UINT, 0xf, att->gmem_offset_stencil, value);
return;
}
- clear_gmem_attachment(cmd, cs, att->format, aspect_write_mask(att->format, mask), att->gmem_offset, value);
+ clear_gmem_attachment(cmd, cs, format, aspect_write_mask(format, mask), att->gmem_offset, value);
trace_end_gmem_clear(&cmd->trace, cs, att->format, att->samples);
}
@@ -2580,12 +2556,13 @@ tu_CmdClearAttachments(VkCommandBuffer commandBuffer,
static void
clear_sysmem_attachment(struct tu_cmd_buffer *cmd,
struct tu_cs *cs,
- VkFormat format,
+ VkFormat vk_format,
VkImageAspectFlags clear_mask,
const VkRenderPassBeginInfo *info,
uint32_t a,
bool separate_stencil)
{
+ enum pipe_format format = tu_vk_format_to_pipe_format(vk_format);
const struct tu_framebuffer *fb = cmd->state.framebuffer;
const struct tu_image_view *iview = cmd->state.attachments[a];
const uint32_t clear_views = cmd->state.pass->attachments[a].clear_views;
@@ -2615,7 +2592,7 @@ clear_sysmem_attachment(struct tu_cmd_buffer *cmd,
ops->teardown(cmd, cs);
trace_end_sysmem_clear(&cmd->trace, cs,
- format, ops == &r3d_ops,
+ vk_format, ops == &r3d_ops,
cmd->state.pass->attachments[a].samples);
}
@@ -2785,7 +2762,7 @@ store_cp_blit(struct tu_cmd_buffer *cmd,
const struct tu_image_view *iview,
uint32_t samples,
bool separate_stencil,
- VkFormat format,
+ enum pipe_format format,
uint32_t gmem_offset,
uint32_t cpp)
{
@@ -2798,12 +2775,12 @@ store_cp_blit(struct tu_cmd_buffer *cmd,
tu_cs_emit_regs(cs,
A6XX_SP_PS_2D_SRC_INFO(
- .color_format = tu6_format_texture(tu_vk_format_to_pipe_format(format), TILE6_2).fmt,
+ .color_format = tu6_format_texture(format, TILE6_2).fmt,
.tile_mode = TILE6_2,
- .srgb = vk_format_is_srgb(format),
+ .srgb = util_format_is_srgb(format),
.samples = tu_msaa_samples(samples),
- .samples_average = !vk_format_is_int(format) &&
- !vk_format_is_depth_or_stencil(format),
+ .samples_average = !util_format_is_pure_integer(format) &&
+ !util_format_is_depth_or_stencil(format),
.unk20 = 1,
.unk22 = 1),
/* note: src size does not matter when not scaling */
@@ -2833,7 +2810,7 @@ store_3d_blit(struct tu_cmd_buffer *cmd,
const struct tu_image_view *iview,
uint32_t dst_samples,
bool separate_stencil,
- VkFormat format,
+ enum pipe_format format,
const VkRect2D *render_area,
uint32_t gmem_offset,
uint32_t cpp)
@@ -2916,9 +2893,9 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
return;
}
- VkFormat format = src->format;
- if (format == VK_FORMAT_D32_SFLOAT_S8_UINT)
- format = VK_FORMAT_D32_SFLOAT;
+ enum pipe_format format = tu_vk_format_to_pipe_format(src->format);
+ if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT)
+ format = PIPE_FORMAT_Z32_FLOAT;
if (dst->samples > 1) {
/* If we hit this path, we have to disable draw states after every tile
@@ -2936,7 +2913,7 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
render_area, src->gmem_offset, src->cpp);
}
if (dst->store_stencil) {
- store_3d_blit(cmd, cs, iview, dst->samples, true, VK_FORMAT_S8_UINT,
+ store_3d_blit(cmd, cs, iview, dst->samples, true, PIPE_FORMAT_S8_UINT,
render_area, src->gmem_offset, src->samples);
}
} else {
@@ -2947,7 +2924,7 @@ tu_store_gmem_attachment(struct tu_cmd_buffer *cmd,
src->gmem_offset, src->cpp);
}
if (dst->store_stencil) {
- store_cp_blit(cmd, cs, iview, src->samples, true, VK_FORMAT_S8_UINT,
+ store_cp_blit(cmd, cs, iview, src->samples, true, PIPE_FORMAT_S8_UINT,
src->gmem_offset_stencil, src->samples);
}
}
diff --git a/src/freedreno/vulkan/tu_image.c b/src/freedreno/vulkan/tu_image.c
index 0a04109b45a..4d9b2e953fa 100644
--- a/src/freedreno/vulkan/tu_image.c
+++ b/src/freedreno/vulkan/tu_image.c
@@ -51,19 +51,19 @@ tu6_plane_count(VkFormat format)
}
}
-VkFormat
+enum pipe_format
tu6_plane_format(VkFormat format, uint32_t plane)
{
switch (format) {
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
/* note: with UBWC, and Y plane UBWC is different from R8_UNORM */
- return plane ? VK_FORMAT_R8G8_UNORM : VK_FORMAT_R8_UNORM;
+ return plane ? PIPE_FORMAT_R8G8_UNORM : PIPE_FORMAT_R8_UNORM;
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
- return VK_FORMAT_R8_UNORM;
+ return PIPE_FORMAT_R8_UNORM;
case VK_FORMAT_D32_SFLOAT_S8_UINT:
- return plane ? VK_FORMAT_S8_UINT : VK_FORMAT_D32_SFLOAT;
+ return plane ? PIPE_FORMAT_S8_UINT : PIPE_FORMAT_Z32_FLOAT;
default:
- return format;
+ return tu_vk_format_to_pipe_format(format);
}
}
@@ -229,7 +229,7 @@ tu_image_view_init(struct tu_image_view *iview,
{
TU_FROM_HANDLE(tu_image, image, pCreateInfo->image);
const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange;
- VkFormat format = pCreateInfo->format;
+ VkFormat vk_format = pCreateInfo->format;
VkImageAspectFlagBits aspect_mask = pCreateInfo->subresourceRange.aspectMask;
const struct VkSamplerYcbcrConversionInfo *ycbcr_conversion =
@@ -243,12 +243,15 @@ tu_image_view_init(struct tu_image_view *iview,
layouts[0] = &image->layout[tu6_plane_index(image->vk_format, aspect_mask)];
+ enum pipe_format format;
if (aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT)
- format = tu6_plane_format(format, tu6_plane_index(format, aspect_mask));
+ format = tu6_plane_format(vk_format, tu6_plane_index(vk_format, aspect_mask));
+ else
+ format = tu_vk_format_to_pipe_format(vk_format);
if (aspect_mask == VK_IMAGE_ASPECT_COLOR_BIT &&
- (format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
- format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM)) {
+ (vk_format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM ||
+ vk_format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM)) {
layouts[1] = &image->layout[1];
layouts[2] = &image->layout[2];
}
@@ -259,8 +262,7 @@ tu_image_view_init(struct tu_image_view *iview,
args.base_miplevel = range->baseMipLevel;
args.layer_count = tu_get_layerCount(image, range);
args.level_count = tu_get_levelCount(image, range);
- args.format = tu_format_for_aspect(tu_vk_format_to_pipe_format(format),
- aspect_mask);
+ args.format = tu_format_for_aspect(format, aspect_mask);
vk_component_mapping_to_pipe_swizzle(pCreateInfo->components, args.swiz);
if (conversion) {
unsigned char conversion_swiz[4], create_swiz[4];
@@ -486,7 +488,7 @@ tu_CreateImage(VkDevice _device,
for (uint32_t i = 0; i < tu6_plane_count(image->vk_format); i++) {
struct fdl_layout *layout = &image->layout[i];
- VkFormat format = tu6_plane_format(image->vk_format, i);
+ enum pipe_format format = tu6_plane_format(image->vk_format, i);
uint32_t width0 = pCreateInfo->extent.width;
uint32_t height0 = pCreateInfo->extent.height;
@@ -524,7 +526,7 @@ tu_CreateImage(VkDevice _device,
layout->tile_mode = tile_mode;
layout->ubwc = ubwc_enabled;
- if (!fdl6_layout(layout, vk_format_to_pipe_format(format),
+ if (!fdl6_layout(layout, format,
pCreateInfo->samples,
width0, height0,
pCreateInfo->extent.depth,
diff --git a/src/freedreno/vulkan/tu_private.h b/src/freedreno/vulkan/tu_private.h
index 03e88d06a2a..850b633f516 100644
--- a/src/freedreno/vulkan/tu_private.h
+++ b/src/freedreno/vulkan/tu_private.h
@@ -1445,7 +1445,7 @@ tu_get_levelCount(const struct tu_image *image,
: range->levelCount;
}
-VkFormat tu6_plane_format(VkFormat format, uint32_t plane);
+enum pipe_format tu6_plane_format(VkFormat format, uint32_t plane);
uint32_t tu6_plane_index(VkFormat format, VkImageAspectFlags aspect_mask);
More information about the mesa-commit
mailing list