KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Emma Anholt 2021-10-05 15:24:31 -07:00 committed by Marge Bot
parent 68f8bbb37e
commit 9202e8cbaf
3 changed files with 189 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

369
src/freedreno/vulkan/tu_clear_blit.c
View File

@ -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)
static enum pipe_format
copy_format(VkFormat vk_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;
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;
format = util_format_snorm_to_unorm(format);
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
return VK_FORMAT_R32_UINT;
switch (format) {
case PIPE_FORMAT_R9G9B9E5_FLOAT:
return PIPE_FORMAT_R32_UINT;
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
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);
}
}

28
src/freedreno/vulkan/tu_image.c
View File

@ -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,

2
src/freedreno/vulkan/tu_private.h
View File

@ -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);