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

v3dv: split v3dv_format hw version dependant code to a new source file

Browse Source 
Reviewed-by: Iago Toral Quiroga <itoral@igalia.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/11310>
This commit is contained in:
Alejandro Piñeiro
2021-06-14 11:35:06 +02:00
parent a3793dbef3
commit f526f92043
12 changed files with 551 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/broadcom/vulkan/meson.build
+1
View File
@@ -54,6 +54,7 @@ libv3dv_files = files(
)
files_per_version = files(
'v3dvx_formats.c',
'v3dvx_image.c',
'v3dvx_pipeline.c',
'v3dvx_queue.c',
src/broadcom/vulkan/v3dv_cmd_buffer.c
+6 -5
View File
@@ -1228,7 +1228,7 @@ cmd_buffer_update_tile_alignment(struct v3dv_cmd_buffer *cmd_buffer)
*/
assert(cmd_buffer->state.framebuffer);
cmd_buffer->state.tile_aligned_render_area =
v3dv_subpass_area_is_tile_aligned(rect,
v3dv_subpass_area_is_tile_aligned(cmd_buffer->device, rect,
cmd_buffer->state.framebuffer,
cmd_buffer->state.pass,
cmd_buffer->state.subpass_idx);
@@ -1287,10 +1287,11 @@ cmd_buffer_state_set_attachment_clear_color(struct v3dv_cmd_buffer *cmd_buffer,
&cmd_buffer->state.pass->attachments[attachment_idx];
uint32_t internal_type, internal_bpp;
const struct v3dv_format *format = v3dv_get_format(attachment->desc.format);
v3dv_get_internal_type_bpp_for_output_format(format->rt_type,
&internal_type,
&internal_bpp);
const struct v3dv_format *format =
v3dv_X(cmd_buffer->device, get_format)(attachment->desc.format);
v3dv_X(cmd_buffer->device, get_internal_type_bpp_for_output_format)
(format->rt_type, &internal_type, &internal_bpp);
uint32_t internal_size = 4 << internal_bpp;
src/broadcom/vulkan/v3dv_formats.c
+17 -394
View File
@@ -25,331 +25,14 @@
#include "vk_util.h"
#include "vk_format_info.h"
#include "broadcom/cle/v3dx_pack.h"
#include "drm-uapi/drm_fourcc.h"
#include "util/format/u_format.h"
#include "vulkan/wsi/wsi_common.h"
#define SWIZ(x,y,z,w) { \
PIPE_SWIZZLE_##x, \
PIPE_SWIZZLE_##y, \
PIPE_SWIZZLE_##z, \
PIPE_SWIZZLE_##w \
}
#define FORMAT(vk, rt, tex, swiz, return_size, supports_filtering) \
[VK_FORMAT_##vk] = { \
true, \
V3D_OUTPUT_IMAGE_FORMAT_##rt, \
TEXTURE_DATA_FORMAT_##tex, \
swiz, \
return_size, \
supports_filtering, \
}
#define SWIZ_X001 SWIZ(X, 0, 0, 1)
#define SWIZ_XY01 SWIZ(X, Y, 0, 1)
#define SWIZ_XYZ1 SWIZ(X, Y, Z, 1)
#define SWIZ_XYZW SWIZ(X, Y, Z, W)
#define SWIZ_YZWX SWIZ(Y, Z, W, X)
#define SWIZ_YZW1 SWIZ(Y, Z, W, 1)
#define SWIZ_ZYXW SWIZ(Z, Y, X, W)
#define SWIZ_ZYX1 SWIZ(Z, Y, X, 1)
#define SWIZ_XXXY SWIZ(X, X, X, Y)
#define SWIZ_XXX1 SWIZ(X, X, X, 1)
#define SWIZ_XXXX SWIZ(X, X, X, X)
#define SWIZ_000X SWIZ(0, 0, 0, X)
#define SWIZ_WXYZ SWIZ(W, X, Y, Z)
/* FIXME: expand format table to describe whether the format is supported
* for buffer surfaces (texel buffers, vertex buffers, etc).
*/
static const struct v3dv_format format_table[] = {
/* Color, 4 channels */
FORMAT(B8G8R8A8_SRGB, SRGB8_ALPHA8, RGBA8, SWIZ_ZYXW, 16, true),
FORMAT(B8G8R8A8_UNORM, RGBA8, RGBA8, SWIZ_ZYXW, 16, true),
FORMAT(R8G8B8A8_SRGB, SRGB8_ALPHA8, RGBA8, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_UNORM, RGBA8, RGBA8, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_SNORM, NO, RGBA8_SNORM, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_SINT, RGBA8I, RGBA8I, SWIZ_XYZW, 16, false),
FORMAT(R8G8B8A8_UINT, RGBA8UI, RGBA8UI, SWIZ_XYZW, 16, false),
FORMAT(R16G16B16A16_SFLOAT, RGBA16F, RGBA16F, SWIZ_XYZW, 16, true),
FORMAT(R16G16B16A16_UNORM, NO, RGBA16, SWIZ_XYZW, 32, true),
FORMAT(R16G16B16A16_SNORM, NO, RGBA16_SNORM, SWIZ_XYZW, 32, true),
FORMAT(R16G16B16A16_SINT, RGBA16I, RGBA16I, SWIZ_XYZW, 16, false),
FORMAT(R16G16B16A16_UINT, RGBA16UI, RGBA16UI, SWIZ_XYZW, 16, false),
FORMAT(R32G32B32A32_SFLOAT, RGBA32F, RGBA32F, SWIZ_XYZW, 32, false),
FORMAT(R32G32B32A32_SINT, RGBA32I, RGBA32I, SWIZ_XYZW, 32, false),
FORMAT(R32G32B32A32_UINT, RGBA32UI, RGBA32UI, SWIZ_XYZW, 32, false),
/* Color, 3 channels */
FORMAT(R32G32B32_SFLOAT, NO, NO, SWIZ_XYZ1, 0, false),
FORMAT(R32G32B32_UINT, NO, NO, SWIZ_XYZ1, 0, false),
FORMAT(R32G32B32_SINT, NO, NO, SWIZ_XYZ1, 0, false),
/* Color, 2 channels */
FORMAT(R8G8_UNORM, RG8, RG8, SWIZ_XY01, 16, true),
FORMAT(R8G8_SNORM, NO, RG8_SNORM, SWIZ_XY01, 16, true),
FORMAT(R8G8_SINT, RG8I, RG8I, SWIZ_XY01, 16, false),
FORMAT(R8G8_UINT, RG8UI, RG8UI, SWIZ_XY01, 16, false),
FORMAT(R16G16_UNORM, NO, RG16, SWIZ_XY01, 32, true),
FORMAT(R16G16_SNORM, NO, RG16_SNORM, SWIZ_XY01, 32, true),
FORMAT(R16G16_SFLOAT, RG16F, RG16F, SWIZ_XY01, 16, true),
FORMAT(R16G16_SINT, RG16I, RG16I, SWIZ_XY01, 16, false),
FORMAT(R16G16_UINT, RG16UI, RG16UI, SWIZ_XY01, 16, false),
FORMAT(R32G32_SFLOAT, RG32F, RG32F, SWIZ_XY01, 32, false),
FORMAT(R32G32_SINT, RG32I, RG32I, SWIZ_XY01, 32, false),
FORMAT(R32G32_UINT, RG32UI, RG32UI, SWIZ_XY01, 32, false),
/* Color, 1 channel */
FORMAT(R8_UNORM, R8, R8, SWIZ_X001, 16, true),
FORMAT(R8_SNORM, NO, R8_SNORM, SWIZ_X001, 16, true),
FORMAT(R8_SINT, R8I, R8I, SWIZ_X001, 16, false),
FORMAT(R8_UINT, R8UI, R8UI, SWIZ_X001, 16, false),
FORMAT(R16_UNORM, NO, R16, SWIZ_X001, 32, true),
FORMAT(R16_SNORM, NO, R16_SNORM, SWIZ_X001, 32, true),
FORMAT(R16_SFLOAT, R16F, R16F, SWIZ_X001, 16, true),
FORMAT(R16_SINT, R16I, R16I, SWIZ_X001, 16, false),
FORMAT(R16_UINT, R16UI, R16UI, SWIZ_X001, 16, false),
FORMAT(R32_SFLOAT, R32F, R32F, SWIZ_X001, 32, false),
FORMAT(R32_SINT, R32I, R32I, SWIZ_X001, 32, false),
FORMAT(R32_UINT, R32UI, R32UI, SWIZ_X001, 32, false),
/* Color, packed */
FORMAT(R4G4B4A4_UNORM_PACK16, ABGR4444, RGBA4, SWIZ_XYZW, 16, true),
FORMAT(B4G4R4A4_UNORM_PACK16, ABGR4444, RGBA4, SWIZ_ZYXW, 16, true), /* Swap RB */
FORMAT(R5G6B5_UNORM_PACK16, BGR565, RGB565, SWIZ_XYZ1, 16, true),
FORMAT(R5G5B5A1_UNORM_PACK16, ABGR1555, RGB5_A1, SWIZ_XYZW, 16, true),
FORMAT(A1R5G5B5_UNORM_PACK16, RGBA5551, A1_RGB5, SWIZ_ZYXW, 16, true), /* Swap RB */
FORMAT(A8B8G8R8_UNORM_PACK32, RGBA8, RGBA8, SWIZ_XYZW, 16, true), /* RGBA8 UNORM */
FORMAT(A8B8G8R8_SNORM_PACK32, NO, RGBA8_SNORM, SWIZ_XYZW, 16, true), /* RGBA8 SNORM */
FORMAT(A8B8G8R8_UINT_PACK32, RGBA8UI, RGBA8UI, SWIZ_XYZW, 16, true), /* RGBA8 UINT */
FORMAT(A8B8G8R8_SINT_PACK32, RGBA8I, RGBA8I, SWIZ_XYZW, 16, true), /* RGBA8 SINT */
FORMAT(A8B8G8R8_SRGB_PACK32, SRGB8_ALPHA8, RGBA8, SWIZ_XYZW, 16, true), /* RGBA8 sRGB */
FORMAT(A2B10G10R10_UNORM_PACK32,RGB10_A2, RGB10_A2, SWIZ_XYZW, 16, true),
FORMAT(A2B10G10R10_UINT_PACK32, RGB10_A2UI, RGB10_A2UI, SWIZ_XYZW, 16, true),
FORMAT(E5B9G9R9_UFLOAT_PACK32, NO, RGB9_E5, SWIZ_XYZ1, 16, true),
FORMAT(B10G11R11_UFLOAT_PACK32, R11F_G11F_B10F,R11F_G11F_B10F, SWIZ_XYZ1, 16, true),
/* Depth */
FORMAT(D16_UNORM, D16, DEPTH_COMP16, SWIZ_X001, 32, false),
FORMAT(D32_SFLOAT, D32F, DEPTH_COMP32F, SWIZ_X001, 32, false),
FORMAT(X8_D24_UNORM_PACK32, D24S8, DEPTH24_X8, SWIZ_X001, 32, false),
/* Depth + Stencil */
FORMAT(D24_UNORM_S8_UINT, D24S8, DEPTH24_X8, SWIZ_X001, 32, false),
/* Compressed: ETC2 / EAC */
FORMAT(ETC2_R8G8B8_UNORM_BLOCK, NO, RGB8_ETC2, SWIZ_XYZ1, 16, true),
FORMAT(ETC2_R8G8B8_SRGB_BLOCK, NO, RGB8_ETC2, SWIZ_XYZ1, 16, true),
FORMAT(ETC2_R8G8B8A1_UNORM_BLOCK, NO, RGB8_PUNCHTHROUGH_ALPHA1, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A1_SRGB_BLOCK, NO, RGB8_PUNCHTHROUGH_ALPHA1, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A8_UNORM_BLOCK, NO, RGBA8_ETC2_EAC, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A8_SRGB_BLOCK, NO, RGBA8_ETC2_EAC, SWIZ_XYZW, 16, true),
FORMAT(EAC_R11_UNORM_BLOCK, NO, R11_EAC, SWIZ_X001, 16, true),
FORMAT(EAC_R11_SNORM_BLOCK, NO, SIGNED_R11_EAC, SWIZ_X001, 16, true),
FORMAT(EAC_R11G11_UNORM_BLOCK, NO, RG11_EAC, SWIZ_XY01, 16, true),
FORMAT(EAC_R11G11_SNORM_BLOCK, NO, SIGNED_RG11_EAC, SWIZ_XY01, 16, true),
/* Compressed: BC1-3 */
FORMAT(BC1_RGB_UNORM_BLOCK, NO, BC1, SWIZ_XYZ1, 16, true),
FORMAT(BC1_RGB_SRGB_BLOCK, NO, BC1, SWIZ_XYZ1, 16, true),
FORMAT(BC1_RGBA_UNORM_BLOCK, NO, BC1, SWIZ_XYZW, 16, true),
FORMAT(BC1_RGBA_SRGB_BLOCK, NO, BC1, SWIZ_XYZW, 16, true),
FORMAT(BC2_UNORM_BLOCK, NO, BC2, SWIZ_XYZW, 16, true),
FORMAT(BC2_SRGB_BLOCK, NO, BC2, SWIZ_XYZW, 16, true),
FORMAT(BC3_UNORM_BLOCK, NO, BC3, SWIZ_XYZW, 16, true),
FORMAT(BC3_SRGB_BLOCK, NO, BC3, SWIZ_XYZW, 16, true),
/* Compressed: ASTC */
FORMAT(ASTC_4x4_UNORM_BLOCK, NO, ASTC_4X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_4x4_SRGB_BLOCK, NO, ASTC_4X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x4_UNORM_BLOCK, NO, ASTC_5X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x4_SRGB_BLOCK, NO, ASTC_5X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x5_UNORM_BLOCK, NO, ASTC_5X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x5_SRGB_BLOCK, NO, ASTC_5X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x5_UNORM_BLOCK, NO, ASTC_6X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x5_SRGB_BLOCK, NO, ASTC_6X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x6_UNORM_BLOCK, NO, ASTC_6X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x6_SRGB_BLOCK, NO, ASTC_6X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x5_UNORM_BLOCK, NO, ASTC_8X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x5_SRGB_BLOCK, NO, ASTC_8X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x6_UNORM_BLOCK, NO, ASTC_8X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x6_SRGB_BLOCK, NO, ASTC_8X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x8_UNORM_BLOCK, NO, ASTC_8X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x8_SRGB_BLOCK, NO, ASTC_8X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x5_UNORM_BLOCK, NO, ASTC_10X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x5_SRGB_BLOCK, NO, ASTC_10X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x6_UNORM_BLOCK, NO, ASTC_10X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x6_SRGB_BLOCK, NO, ASTC_10X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x8_UNORM_BLOCK, NO, ASTC_10X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x8_SRGB_BLOCK, NO, ASTC_10X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x10_UNORM_BLOCK, NO, ASTC_10X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x10_SRGB_BLOCK, NO, ASTC_10X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x10_UNORM_BLOCK, NO, ASTC_12X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x10_SRGB_BLOCK, NO, ASTC_12X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x12_UNORM_BLOCK, NO, ASTC_12X12, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x12_SRGB_BLOCK, NO, ASTC_12X12, SWIZ_XYZW, 16, true),
};
const struct v3dv_format *
v3dv_get_format(VkFormat format)
{
if (format < ARRAY_SIZE(format_table) && format_table[format].supported)
return &format_table[format];
else
return NULL;
}
void
v3dv_get_internal_type_bpp_for_output_format(uint32_t format,
uint32_t *type,
uint32_t *bpp)
{
switch (format) {
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8:
case V3D_OUTPUT_IMAGE_FORMAT_RGB8:
case V3D_OUTPUT_IMAGE_FORMAT_RG8:
case V3D_OUTPUT_IMAGE_FORMAT_R8:
case V3D_OUTPUT_IMAGE_FORMAT_ABGR4444:
case V3D_OUTPUT_IMAGE_FORMAT_BGR565:
case V3D_OUTPUT_IMAGE_FORMAT_ABGR1555:
*type = V3D_INTERNAL_TYPE_8;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8I:
case V3D_OUTPUT_IMAGE_FORMAT_RG8I:
case V3D_OUTPUT_IMAGE_FORMAT_R8I:
*type = V3D_INTERNAL_TYPE_8I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8UI:
case V3D_OUTPUT_IMAGE_FORMAT_RG8UI:
case V3D_OUTPUT_IMAGE_FORMAT_R8UI:
*type = V3D_INTERNAL_TYPE_8UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_SRGB8_ALPHA8:
case V3D_OUTPUT_IMAGE_FORMAT_SRGB:
case V3D_OUTPUT_IMAGE_FORMAT_RGB10_A2:
case V3D_OUTPUT_IMAGE_FORMAT_R11F_G11F_B10F:
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16F:
/* Note that sRGB RTs are stored in the tile buffer at 16F,
* and the conversion to sRGB happens at tilebuffer load/store.
*/
*type = V3D_INTERNAL_TYPE_16F;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16F:
case V3D_OUTPUT_IMAGE_FORMAT_R16F:
*type = V3D_INTERNAL_TYPE_16F;
/* Use 64bpp to make sure the TLB doesn't throw away the alpha
* channel before alpha test happens.
*/
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16I:
*type = V3D_INTERNAL_TYPE_16I;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16I:
case V3D_OUTPUT_IMAGE_FORMAT_R16I:
*type = V3D_INTERNAL_TYPE_16I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGB10_A2UI:
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16UI:
*type = V3D_INTERNAL_TYPE_16UI;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16UI:
case V3D_OUTPUT_IMAGE_FORMAT_R16UI:
*type = V3D_INTERNAL_TYPE_16UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_32;
break;
default:
/* Provide some default values, as we'll be called at RB
* creation time, even if an RB with this format isn't supported.
*/
*type = V3D_INTERNAL_TYPE_8;
*bpp = V3D_INTERNAL_BPP_32;
break;
}
}
bool
v3dv_format_supports_tlb_resolve(const struct v3dv_format *format)
{
uint32_t type, bpp;
v3dv_get_internal_type_bpp_for_output_format(format->rt_type, &type, &bpp);
return type == V3D_INTERNAL_TYPE_8 || type == V3D_INTERNAL_TYPE_16F;
}
const uint8_t *
v3dv_get_format_swizzle(VkFormat f)
v3dv_get_format_swizzle(struct v3dv_device *device, VkFormat f)
{
const struct v3dv_format *vf = v3dv_get_format(f);
const struct v3dv_format *vf = v3dv_X(device, get_format)(f);
static const uint8_t fallback[] = {0, 1, 2, 3};
if (!vf)
@@ -368,51 +51,6 @@ v3dv_get_tex_return_size(const struct v3dv_format *vf,
return vf->return_size;
}
bool
v3dv_tfu_supports_tex_format(const struct v3d_device_info *devinfo,
uint32_t tex_format)
{
assert(devinfo->ver >= 42);
switch (tex_format) {
case TEXTURE_DATA_FORMAT_R8:
case TEXTURE_DATA_FORMAT_R8_SNORM:
case TEXTURE_DATA_FORMAT_RG8:
case TEXTURE_DATA_FORMAT_RG8_SNORM:
case TEXTURE_DATA_FORMAT_RGBA8:
case TEXTURE_DATA_FORMAT_RGBA8_SNORM:
case TEXTURE_DATA_FORMAT_RGB565:
case TEXTURE_DATA_FORMAT_RGBA4:
case TEXTURE_DATA_FORMAT_RGB5_A1:
case TEXTURE_DATA_FORMAT_RGB10_A2:
case TEXTURE_DATA_FORMAT_R16:
case TEXTURE_DATA_FORMAT_R16_SNORM:
case TEXTURE_DATA_FORMAT_RG16:
case TEXTURE_DATA_FORMAT_RG16_SNORM:
case TEXTURE_DATA_FORMAT_RGBA16:
case TEXTURE_DATA_FORMAT_RGBA16_SNORM:
case TEXTURE_DATA_FORMAT_R16F:
case TEXTURE_DATA_FORMAT_RG16F:
case TEXTURE_DATA_FORMAT_RGBA16F:
case TEXTURE_DATA_FORMAT_R11F_G11F_B10F:
case TEXTURE_DATA_FORMAT_R4:
case TEXTURE_DATA_FORMAT_RGB9_E5:
case TEXTURE_DATA_FORMAT_R32F:
case TEXTURE_DATA_FORMAT_RG32F:
case TEXTURE_DATA_FORMAT_RGBA32F:
case TEXTURE_DATA_FORMAT_RGB8_ETC2:
case TEXTURE_DATA_FORMAT_RGB8_PUNCHTHROUGH_ALPHA1:
case TEXTURE_DATA_FORMAT_RGBA8_ETC2_EAC:
case TEXTURE_DATA_FORMAT_R11_EAC:
case TEXTURE_DATA_FORMAT_SIGNED_R11_EAC:
case TEXTURE_DATA_FORMAT_RG11_EAC:
case TEXTURE_DATA_FORMAT_SIGNED_RG11_EAC:
return true;
default:
return false;
}
}
/* Some cases of transfer operations are raw data copies that don't depend
* on the semantics of the pixel format (no pixel format conversions are
* involved). In these cases, it is safe to choose any format supported by
@@ -420,7 +58,7 @@ v3dv_tfu_supports_tex_format(const struct v3d_device_info *devinfo,
* TFU paths with formats that are not TFU supported otherwise.
*/
const struct v3dv_format *
v3dv_get_compatible_tfu_format(const struct v3d_device_info *devinfo,
v3dv_get_compatible_tfu_format(struct v3dv_device *device,
uint32_t bpp,
VkFormat *out_vk_format)
{
@@ -437,32 +75,15 @@ v3dv_get_compatible_tfu_format(const struct v3d_device_info *devinfo,
if (out_vk_format)
*out_vk_format = vk_format;
const struct v3dv_format *format = v3dv_get_format(vk_format);
assert(v3dv_tfu_supports_tex_format(devinfo, format->tex_type));
const struct v3dv_format *format = v3dv_X(device, get_format)(vk_format);
assert(v3dv_X(device, tfu_supports_tex_format)(format->tex_type));
return format;
}
static bool
format_supports_blending(const struct v3dv_format *format)
{
/* Hardware blending is only supported on render targets that are configured
* 4x8-bit unorm, 2x16-bit float or 4x16-bit float.
*/
uint32_t type, bpp;
v3dv_get_internal_type_bpp_for_output_format(format->rt_type, &type, &bpp);
switch (type) {
case V3D_INTERNAL_TYPE_8:
return bpp == V3D_INTERNAL_BPP_32;
case V3D_INTERNAL_TYPE_16F:
return bpp == V3D_INTERNAL_BPP_32 || V3D_INTERNAL_BPP_64;
default:
return false;
}
}
static VkFormatFeatureFlags
image_format_features(VkFormat vk_format,
image_format_features(struct v3dv_physical_device *pdevice,
VkFormat vk_format,
const struct v3dv_format *v3dv_format,
VkImageTiling tiling)
{
@@ -507,7 +128,7 @@ image_format_features(VkFormat vk_format,
if (aspects & VK_IMAGE_ASPECT_COLOR_BIT) {
flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
VK_FORMAT_FEATURE_BLIT_DST_BIT;
if (format_supports_blending(v3dv_format))
if (v3dv_X(pdevice, format_supports_blending)(v3dv_format))
flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
} else if (aspects & zs_aspects) {
flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT |
@@ -587,10 +208,11 @@ buffer_format_features(VkFormat vk_format, const struct v3dv_format *v3dv_format
}
bool
v3dv_buffer_format_supports_features(VkFormat vk_format,
v3dv_buffer_format_supports_features(struct v3dv_device *device,
VkFormat vk_format,
VkFormatFeatureFlags features)
{
const struct v3dv_format *v3dv_format = v3dv_get_format(vk_format);
const struct v3dv_format *v3dv_format = v3dv_X(device, get_format)(vk_format);
const VkFormatFeatureFlags supported =
buffer_format_features(vk_format, v3dv_format);
return (supported & features) == features;
@@ -601,13 +223,14 @@ v3dv_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
VkFormat format,
VkFormatProperties* pFormatProperties)
{
const struct v3dv_format *v3dv_format = v3dv_get_format(format);
V3DV_FROM_HANDLE(v3dv_physical_device, pdevice, physicalDevice);
const struct v3dv_format *v3dv_format = v3dv_X(pdevice, get_format)(format);
*pFormatProperties = (VkFormatProperties) {
.linearTilingFeatures =
image_format_features(format, v3dv_format, VK_IMAGE_TILING_LINEAR),
image_format_features(pdevice, format, v3dv_format, VK_IMAGE_TILING_LINEAR),
.optimalTilingFeatures =
image_format_features(format, v3dv_format, VK_IMAGE_TILING_OPTIMAL),
image_format_features(pdevice, format, v3dv_format, VK_IMAGE_TILING_OPTIMAL),
.bufferFeatures =
buffer_format_features(format, v3dv_format),
};
@@ -656,9 +279,9 @@ get_image_format_properties(
VkImageFormatProperties *pImageFormatProperties,
VkSamplerYcbcrConversionImageFormatProperties *pYcbcrImageFormatProperties)
{
const struct v3dv_format *v3dv_format = v3dv_get_format(info->format);
const struct v3dv_format *v3dv_format = v3dv_X(physical_device, get_format)(info->format);
VkFormatFeatureFlags format_feature_flags =
image_format_features(info->format, v3dv_format, tiling);
image_format_features(physical_device, info->format, v3dv_format, tiling);
if (!format_feature_flags)
goto unsupported;
src/broadcom/vulkan/v3dv_image.c
+8 -10
View File
@@ -308,7 +308,7 @@ create_image(struct v3dv_device *device,
else
tiling = VK_IMAGE_TILING_LINEAR;
const struct v3dv_format *format = v3dv_get_format(pCreateInfo->format);
const struct v3dv_format *format = v3dv_X(device, get_format)(pCreateInfo->format);
v3dv_assert(format != NULL && format->supported);
image = vk_object_zalloc(&device->vk, pAllocator, sizeof(*image),
@@ -607,18 +607,17 @@ v3dv_CreateImageView(VkDevice _device,
}
iview->vk_format = format;
iview->format = v3dv_get_format(format);
iview->format = v3dv_X(device, get_format)(format);
assert(iview->format && iview->format->supported);
if (vk_format_is_depth_or_stencil(iview->vk_format)) {
iview->internal_type = v3dv_get_internal_depth_type(iview->vk_format);
} else {
v3dv_get_internal_type_bpp_for_output_format(iview->format->rt_type,
&iview->internal_type,
&iview->internal_bpp);
v3dv_X(device, get_internal_type_bpp_for_output_format)
(iview->format->rt_type, &iview->internal_type, &iview->internal_bpp);
}
const uint8_t *format_swizzle = v3dv_get_format_swizzle(format);
const uint8_t *format_swizzle = v3dv_get_format_swizzle(device, format);
util_format_compose_swizzles(format_swizzle, image_view_swizzle,
iview->swizzle);
iview->swap_rb = iview->swizzle[0] == PIPE_SWIZZLE_Z;
@@ -675,11 +674,10 @@ v3dv_CreateBufferView(VkDevice _device,
view->size = view->offset + range;
view->num_elements = num_elements;
view->vk_format = pCreateInfo->format;
view->format = v3dv_get_format(view->vk_format);
view->format = v3dv_X(device, get_format)(view->vk_format);
v3dv_get_internal_type_bpp_for_output_format(view->format->rt_type,
&view->internal_type,
&view->internal_bpp);
v3dv_X(device, get_internal_type_bpp_for_output_format)
(view->format->rt_type, &view->internal_type, &view->internal_bpp);
if (buffer->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT ||
buffer->usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)
src/broadcom/vulkan/v3dv_meta_clear.c
+4 -4
View File
@@ -1410,10 +1410,10 @@ emit_tlb_clear_job(struct v3dv_cmd_buffer *cmd_buffer,
uint32_t internal_type, internal_bpp, internal_size;
const struct v3dv_format *format =
v3dv_get_format(attachment->desc.format);
v3dv_get_internal_type_bpp_for_output_format(format->rt_type,
&internal_type,
&internal_bpp);
v3dv_X(cmd_buffer->device, get_format)(attachment->desc.format);
v3dv_X(cmd_buffer->device, get_internal_type_bpp_for_output_format)
(format->rt_type, &internal_type, &internal_bpp);
internal_size = 4 << internal_bpp;
uint32_t clear_color[4] = { 0 };
src/broadcom/vulkan/v3dv_meta_copy.c
+61 -54
View File
@@ -261,7 +261,8 @@ struct framebuffer_data {
};
static void
setup_framebuffer_data(struct framebuffer_data *fb,
setup_framebuffer_data(struct v3dv_device *device,
struct framebuffer_data *fb,
VkFormat vk_format,
uint32_t internal_type,
const struct v3dv_frame_tiling *tiling)
@@ -280,7 +281,7 @@ setup_framebuffer_data(struct framebuffer_data *fb,
fb->max_y_supertile = (tiling->height - 1) / supertile_h_in_pixels;
fb->vk_format = vk_format;
fb->format = v3dv_get_format(vk_format);
fb->format = v3dv_X(device, get_format)(vk_format);
fb->internal_depth_type = V3D_INTERNAL_TYPE_DEPTH_32F;
if (vk_format_is_depth_or_stencil(vk_format))
@@ -350,14 +351,15 @@ choose_tlb_format(struct framebuffer_data *framebuffer,
}
static inline bool
format_needs_rb_swap(VkFormat format)
format_needs_rb_swap(struct v3dv_device *device, VkFormat format)
{
const uint8_t *swizzle = v3dv_get_format_swizzle(format);
const uint8_t *swizzle = v3dv_get_format_swizzle(device, format);
return swizzle[0] == PIPE_SWIZZLE_Z;
}
static void
get_internal_type_bpp_for_image_aspects(VkFormat vk_format,
get_internal_type_bpp_for_image_aspects(struct v3dv_device *device,
VkFormat vk_format,
VkImageAspectFlags aspect_mask,
uint32_t *internal_type,
uint32_t *internal_bpp)
@@ -394,10 +396,9 @@ get_internal_type_bpp_for_image_aspects(VkFormat vk_format,
break;
}
} else {
const struct v3dv_format *format = v3dv_get_format(vk_format);
v3dv_get_internal_type_bpp_for_output_format(format->rt_type,
internal_type,
internal_bpp);
const struct v3dv_format *format = v3dv_X(device, get_format)(vk_format);
v3dv_X(device, get_internal_type_bpp_for_output_format)
(format->rt_type, internal_type, internal_bpp);
}
}
@@ -614,7 +615,8 @@ emit_linear_store(struct v3dv_cl *cl,
}
static void
emit_image_load(struct v3dv_cl *cl,
emit_image_load(struct v3dv_device *device,
struct v3dv_cl *cl,
struct framebuffer_data *framebuffer,
struct v3dv_image *image,
VkImageAspectFlags aspect,
@@ -674,7 +676,7 @@ emit_image_load(struct v3dv_cl *cl,
/* This is not a raw data copy (i.e. we are clearing the image),
* so we need to make sure we respect the format swizzle.
*/
needs_rb_swap = format_needs_rb_swap(framebuffer->vk_format);
needs_rb_swap = format_needs_rb_swap(device, framebuffer->vk_format);
}
load.r_b_swap = needs_rb_swap;
@@ -696,7 +698,8 @@ emit_image_load(struct v3dv_cl *cl,
}
static void
emit_image_store(struct v3dv_cl *cl,
emit_image_store(struct v3dv_device *device,
struct v3dv_cl *cl,
struct framebuffer_data *framebuffer,
struct v3dv_image *image,
VkImageAspectFlags aspect,
@@ -730,7 +733,7 @@ emit_image_store(struct v3dv_cl *cl,
needs_chan_reverse = true;
} else if (!is_copy_from_buffer && !is_copy_to_buffer &&
(aspect & VK_IMAGE_ASPECT_COLOR_BIT)) {
needs_rb_swap = format_needs_rb_swap(framebuffer->vk_format);
needs_rb_swap = format_needs_rb_swap(device, framebuffer->vk_format);
}
store.r_b_swap = needs_rb_swap;
@@ -782,7 +785,7 @@ emit_copy_layer_to_buffer_per_tile_list(struct v3dv_job *job,
region->imageSubresource.baseArrayLayer + layer_offset :
region->imageOffset.z + layer_offset;
emit_image_load(cl, framebuffer, image,
emit_image_load(job->device, cl, framebuffer, image,
region->imageSubresource.aspectMask,
image_layer,
region->imageSubresource.mipLevel,
@@ -887,7 +890,7 @@ copy_image_to_buffer_tlb(struct v3dv_cmd_buffer *cmd_buffer,
return false;
uint32_t internal_type, internal_bpp;
get_internal_type_bpp_for_image_aspects(fb_format,
get_internal_type_bpp_for_image_aspects(cmd_buffer->device, fb_format,
region->imageSubresource.aspectMask,
&internal_type, &internal_bpp);
@@ -912,8 +915,8 @@ copy_image_to_buffer_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(cmd_buffer->device, &framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
emit_copy_image_to_buffer_rcl(job, buffer, image, &framebuffer, region);
@@ -1392,7 +1395,7 @@ emit_copy_image_layer_per_tile_list(struct v3dv_job *job,
region->srcSubresource.baseArrayLayer + layer_offset :
region->srcOffset.z + layer_offset;
emit_image_load(cl, framebuffer, src,
emit_image_load(job->device, cl, framebuffer, src,
region->srcSubresource.aspectMask,
src_layer,
region->srcSubresource.mipLevel,
@@ -1410,7 +1413,7 @@ emit_copy_image_layer_per_tile_list(struct v3dv_job *job,
region->dstSubresource.baseArrayLayer + layer_offset :
region->dstOffset.z + layer_offset;
emit_image_store(cl, framebuffer, dst,
emit_image_store(job->device, cl, framebuffer, dst,
region->dstSubresource.aspectMask,
dst_layer,
region->dstSubresource.mipLevel,
@@ -1643,7 +1646,7 @@ copy_image_tfu(struct v3dv_cmd_buffer *cmd_buffer,
*/
assert(dst->cpp == src->cpp);
const struct v3dv_format *format =
v3dv_get_compatible_tfu_format(&cmd_buffer->device->devinfo,
v3dv_get_compatible_tfu_format(cmd_buffer->device,
dst->cpp, NULL);
/* Emit a TFU job for each layer to blit */
@@ -1691,7 +1694,7 @@ copy_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
assert(region->dstSubresource.aspectMask ==
region->srcSubresource.aspectMask);
uint32_t internal_type, internal_bpp;
get_internal_type_bpp_for_image_aspects(fb_format,
get_internal_type_bpp_for_image_aspects(cmd_buffer->device, fb_format,
region->dstSubresource.aspectMask,
&internal_type, &internal_bpp);
@@ -1727,8 +1730,8 @@ copy_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
src->samples > VK_SAMPLE_COUNT_1_BIT);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(job->device, &framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
emit_copy_image_rcl(job, dst, src, &framebuffer, region);
@@ -1873,7 +1876,7 @@ copy_image_blit(struct v3dv_cmd_buffer *cmd_buffer,
if (format == VK_FORMAT_UNDEFINED)
return false;
const struct v3dv_format *f = v3dv_get_format(format);
const struct v3dv_format *f = v3dv_X(cmd_buffer->device, get_format)(format);
if (!f->supported || f->tex_type == TEXTURE_DATA_FORMAT_NO)
return false;
}
@@ -1979,8 +1982,8 @@ emit_clear_image_per_tile_list(struct v3dv_job *job,
cl_emit(cl, BRANCH_TO_IMPLICIT_TILE_LIST, branch);
emit_image_store(cl, framebuffer, image, aspects, layer, level,
false, false, false);
emit_image_store(job->device, cl, framebuffer, image, aspects,
layer, level, false, false, false);
cl_emit(cl, END_OF_TILE_MARKER, end);
@@ -2071,7 +2074,8 @@ clear_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
return false;
uint32_t internal_type, internal_bpp;
get_internal_type_bpp_for_image_aspects(fb_format, range->aspectMask,
get_internal_type_bpp_for_image_aspects(cmd_buffer->device, fb_format,
range->aspectMask,
&internal_type, &internal_bpp);
union v3dv_clear_value hw_clear_value = { 0 };
@@ -2126,8 +2130,8 @@ clear_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
image->samples > VK_SAMPLE_COUNT_1_BIT);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(job->device, &framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
@@ -2357,8 +2361,8 @@ copy_buffer(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, vk_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(job->device, &framebuffer, vk_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
@@ -2543,8 +2547,9 @@ fill_buffer(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, 1, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, VK_FORMAT_R8G8B8A8_UINT,
internal_type, &job->frame_tiling);
setup_framebuffer_data(cmd_buffer->device, &framebuffer,
VK_FORMAT_R8G8B8A8_UINT, internal_type,
&job->frame_tiling);
v3dv_job_emit_binning_flush(job);
@@ -2644,7 +2649,7 @@ copy_buffer_to_image_tfu(struct v3dv_cmd_buffer *cmd_buffer,
* texel size instead, which expands the list of formats we can handle here.
*/
const struct v3dv_format *format =
v3dv_get_compatible_tfu_format(&cmd_buffer->device->devinfo,
v3dv_get_compatible_tfu_format(cmd_buffer->device,
image->cpp, NULL);
const uint32_t mip_level = region->imageSubresource.mipLevel;
@@ -2775,12 +2780,12 @@ emit_copy_buffer_to_layer_per_tile_list(struct v3dv_job *job,
*/
if (framebuffer->vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
if (imgrsc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
emit_image_load(cl, framebuffer, image, VK_IMAGE_ASPECT_STENCIL_BIT,
emit_image_load(job->device, cl, framebuffer, image, VK_IMAGE_ASPECT_STENCIL_BIT,
imgrsc->baseArrayLayer + layer, imgrsc->mipLevel,
false, false);
} else {
assert(imgrsc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT);
emit_image_load(cl, framebuffer, image, VK_IMAGE_ASPECT_DEPTH_BIT,
emit_image_load(job->device, cl, framebuffer, image, VK_IMAGE_ASPECT_DEPTH_BIT,
imgrsc->baseArrayLayer + layer, imgrsc->mipLevel,
false, false);
}
@@ -2791,18 +2796,20 @@ emit_copy_buffer_to_layer_per_tile_list(struct v3dv_job *job,
cl_emit(cl, BRANCH_TO_IMPLICIT_TILE_LIST, branch);
/* Store TLB to image */
emit_image_store(cl, framebuffer, image, imgrsc->aspectMask,
emit_image_store(job->device, cl, framebuffer, image, imgrsc->aspectMask,
imgrsc->baseArrayLayer + layer, imgrsc->mipLevel,
false, true, false);
if (framebuffer->vk_format == VK_FORMAT_D24_UNORM_S8_UINT) {
if (imgrsc->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
emit_image_store(cl, framebuffer, image, VK_IMAGE_ASPECT_STENCIL_BIT,
emit_image_store(job->device, cl, framebuffer, image,
VK_IMAGE_ASPECT_STENCIL_BIT,
imgrsc->baseArrayLayer + layer, imgrsc->mipLevel,
false, false, false);
} else {
assert(imgrsc->aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT);
emit_image_store(cl, framebuffer, image, VK_IMAGE_ASPECT_DEPTH_BIT,
emit_image_store(job->device, cl, framebuffer, image,
VK_IMAGE_ASPECT_DEPTH_BIT,
imgrsc->baseArrayLayer + layer, imgrsc->mipLevel,
false, false, false);
}
@@ -2862,10 +2869,9 @@ copy_buffer_to_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
return false;
uint32_t internal_type, internal_bpp;
get_internal_type_bpp_for_image_aspects(fb_format,
get_internal_type_bpp_for_image_aspects(cmd_buffer->device, fb_format,
region->imageSubresource.aspectMask,
&internal_type, &internal_bpp);
uint32_t num_layers;
if (image->type != VK_IMAGE_TYPE_3D)
num_layers = region->imageSubresource.layerCount;
@@ -2887,8 +2893,8 @@ copy_buffer_to_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, false);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(job->device, &framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
emit_copy_buffer_to_image_rcl(job, image, buffer, &framebuffer, region);
@@ -3355,7 +3361,8 @@ texel_buffer_shader_copy(struct v3dv_cmd_buffer *cmd_buffer,
*/
if (!(buffer->usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT)) {
if (v3dv_buffer_format_supports_features(
src_format, VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
cmd_buffer->device, src_format,
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
buffer->usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
} else {
return handled;
@@ -3532,7 +3539,7 @@ texel_buffer_shader_copy(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_render_pass_from_handle(pipeline->pass);
can_skip_tlb_load =
cmask == full_cmask &&
v3dv_subpass_area_is_tile_aligned(&render_area,
v3dv_subpass_area_is_tile_aligned(cmd_buffer->device, &render_area,
v3dv_framebuffer_from_handle(fb),
pipeline_pass, 0);
}
@@ -4184,7 +4191,7 @@ blit_tfu(struct v3dv_cmd_buffer *cmd_buffer,
* compatible based on its texel size.
*/
const struct v3dv_format *format =
v3dv_get_compatible_tfu_format(&cmd_buffer->device->devinfo,
v3dv_get_compatible_tfu_format(cmd_buffer->device,
dst->cpp, NULL);
/* Emit a TFU job for each layer to blit */
@@ -5477,8 +5484,8 @@ blit_shader(struct v3dv_cmd_buffer *cmd_buffer,
v3dv_render_pass_from_handle(pipeline->pass);
can_skip_tlb_load =
cmask == full_cmask &&
v3dv_subpass_area_is_tile_aligned(&render_area, framebuffer,
pipeline_pass, 0);
v3dv_subpass_area_is_tile_aligned(cmd_buffer->device, &render_area,
framebuffer, pipeline_pass, 0);
}
/* Record blit */
@@ -5583,7 +5590,7 @@ emit_resolve_image_layer_per_tile_list(struct v3dv_job *job,
region->srcSubresource.baseArrayLayer + layer_offset :
region->srcOffset.z + layer_offset;
emit_image_load(cl, framebuffer, src,
emit_image_load(job->device, cl, framebuffer, src,
region->srcSubresource.aspectMask,
src_layer,
region->srcSubresource.mipLevel,
@@ -5601,7 +5608,7 @@ emit_resolve_image_layer_per_tile_list(struct v3dv_job *job,
region->dstSubresource.baseArrayLayer + layer_offset :
region->dstOffset.z + layer_offset;
emit_image_store(cl, framebuffer, dst,
emit_image_store(job->device, cl, framebuffer, dst,
region->dstSubresource.aspectMask,
dst_layer,
region->dstSubresource.mipLevel,
@@ -5657,7 +5664,7 @@ resolve_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
return false;
}
if (!v3dv_format_supports_tlb_resolve(src->format))
if (!v3dv_X(cmd_buffer->device, format_supports_tlb_resolve)(src->format))
return false;
const VkFormat fb_format = src->vk_format;
@@ -5680,15 +5687,15 @@ resolve_image_tlb(struct v3dv_cmd_buffer *cmd_buffer,
const uint32_t height = DIV_ROUND_UP(region->extent.height, block_h);
uint32_t internal_type, internal_bpp;
get_internal_type_bpp_for_image_aspects(fb_format,
get_internal_type_bpp_for_image_aspects(cmd_buffer->device, fb_format,
region->srcSubresource.aspectMask,
&internal_type, &internal_bpp);
v3dv_job_start_frame(job, width, height, num_layers, 1, internal_bpp, true);
struct framebuffer_data framebuffer;
setup_framebuffer_data(&framebuffer, fb_format, internal_type,
&job->frame_tiling);
setup_framebuffer_data(job->device, &framebuffer, fb_format,
internal_type, &job->frame_tiling);
v3dv_job_emit_binning_flush(job);
emit_resolve_image_rcl(job, dst, src, &framebuffer, region);
src/broadcom/vulkan/v3dv_pass.c
+20 -15
View File
@@ -33,14 +33,16 @@ num_subpass_attachments(const VkSubpassDescription *desc)
}
static void
set_use_tlb_resolve(struct v3dv_render_pass_attachment *att)
set_use_tlb_resolve(struct v3dv_device *device,
struct v3dv_render_pass_attachment *att)
{
const struct v3dv_format *format = v3dv_get_format(att->desc.format);
att->use_tlb_resolve = v3dv_format_supports_tlb_resolve(format);
const struct v3dv_format *format = v3dv_X(device, get_format)(att->desc.format);
att->use_tlb_resolve = v3dv_X(device, format_supports_tlb_resolve)(format);
}
static void
pass_find_subpass_range_for_attachments(struct v3dv_render_pass *pass)
pass_find_subpass_range_for_attachments(struct v3dv_device *device,
struct v3dv_render_pass *pass)
{
for (uint32_t i = 0; i < pass->attachment_count; i++) {
pass->attachments[i].first_subpass = pass->subpass_count - 1;
@@ -62,7 +64,7 @@ pass_find_subpass_range_for_attachments(struct v3dv_render_pass *pass)
if (subpass->resolve_attachments &&
subpass->resolve_attachments[j].attachment != VK_ATTACHMENT_UNUSED) {
set_use_tlb_resolve(&pass->attachments[attachment_idx]);
set_use_tlb_resolve(device, &pass->attachments[attachment_idx]);
}
}
@@ -223,7 +225,7 @@ v3dv_CreateRenderPass(VkDevice _device,
}
}
pass_find_subpass_range_for_attachments(pass);
pass_find_subpass_range_for_attachments(device, pass);
/* FIXME: handle subpass dependencies */
@@ -248,7 +250,8 @@ v3dv_DestroyRenderPass(VkDevice _device,
}
static void
subpass_get_granularity(struct v3dv_render_pass *pass,
subpass_get_granularity(struct v3dv_device *device,
struct v3dv_render_pass *pass,
uint32_t subpass_idx,
VkExtent2D *granularity)
{
@@ -276,11 +279,11 @@ subpass_get_granularity(struct v3dv_render_pass *pass,
continue;
const VkAttachmentDescription *desc =
&pass->attachments[attachment_idx].desc;
const struct v3dv_format *format = v3dv_get_format(desc->format);
const struct v3dv_format *format = v3dv_X(device, get_format)(desc->format);
uint32_t internal_type, internal_bpp;
v3dv_get_internal_type_bpp_for_output_format(format->rt_type,
&internal_type,
&internal_bpp);
v3dv_X(device, get_internal_type_bpp_for_output_format)
(format->rt_type, &internal_type, &internal_bpp);
max_internal_bpp = MAX2(max_internal_bpp, internal_bpp);
}
@@ -300,11 +303,12 @@ subpass_get_granularity(struct v3dv_render_pass *pass,
}
VKAPI_ATTR void VKAPI_CALL
v3dv_GetRenderAreaGranularity(VkDevice device,
v3dv_GetRenderAreaGranularity(VkDevice _device,
VkRenderPass renderPass,
VkExtent2D *pGranularity)
{
V3DV_FROM_HANDLE(v3dv_render_pass, pass, renderPass);
V3DV_FROM_HANDLE(v3dv_device, device, _device);
*pGranularity = (VkExtent2D) {
.width = 64,
@@ -313,7 +317,7 @@ v3dv_GetRenderAreaGranularity(VkDevice device,
for (uint32_t i = 0; i < pass->subpass_count; i++) {
VkExtent2D sg;
subpass_get_granularity(pass, i, &sg);
subpass_get_granularity(device, pass, i, &sg);
pGranularity->width = MIN2(pGranularity->width, sg.width);
pGranularity->height = MIN2(pGranularity->height, sg.height);
}
@@ -341,7 +345,8 @@ v3dv_GetRenderAreaGranularity(VkDevice device,
* In that case, we can't flag the area as being aligned.
*/
bool
v3dv_subpass_area_is_tile_aligned(const VkRect2D *area,
v3dv_subpass_area_is_tile_aligned(struct v3dv_device *device,
const VkRect2D *area,
struct v3dv_framebuffer *fb,
struct v3dv_render_pass *pass,
uint32_t subpass_idx)
@@ -349,7 +354,7 @@ v3dv_subpass_area_is_tile_aligned(const VkRect2D *area,
assert(subpass_idx < pass->subpass_count);
VkExtent2D granularity;
subpass_get_granularity(pass, subpass_idx, &granularity);
subpass_get_granularity(device, pass, subpass_idx, &granularity);
return area->offset.x % granularity.width == 0 &&
area->offset.y % granularity.height == 0 &&
src/broadcom/vulkan/v3dv_pipeline.c
+4 -2
View File
@@ -1191,7 +1191,8 @@ pipeline_populate_v3d_fs_key(struct v3d_fs_key *key,
*/
if (key->logicop_func != PIPE_LOGICOP_COPY) {
key->color_fmt[i].format = fb_pipe_format;
key->color_fmt[i].swizzle = v3dv_get_format_swizzle(fb_format);
key->color_fmt[i].swizzle =
v3dv_get_format_swizzle(p_stage->pipeline->device, fb_format);
}
const struct util_format_description *desc =
@@ -1873,7 +1874,8 @@ pipeline_populate_graphics_key(struct v3dv_pipeline *pipeline,
*/
if (key->logicop_func != PIPE_LOGICOP_COPY) {
key->color_fmt[i].format = fb_pipe_format;
key->color_fmt[i].swizzle = v3dv_get_format_swizzle(fb_format);
key->color_fmt[i].swizzle = v3dv_get_format_swizzle(pipeline->device,
fb_format);
}
const struct util_format_description *desc =
src/broadcom/vulkan/v3dv_private.h
+7 -9
View File
@@ -659,10 +659,12 @@ void v3dv_framebuffer_compute_internal_bpp_msaa(const struct v3dv_framebuffer *f
const struct v3dv_subpass *subpass,
uint8_t *max_bpp, bool *msaa);
bool v3dv_subpass_area_is_tile_aligned(const VkRect2D *area,
bool v3dv_subpass_area_is_tile_aligned(struct v3dv_device *device,
const VkRect2D *area,
struct v3dv_framebuffer *fb,
struct v3dv_render_pass *pass,
uint32_t subpass_idx);
struct v3dv_cmd_pool {
struct vk_object_base base;
@@ -1889,18 +1891,14 @@ VkResult __vk_errorf(struct v3dv_instance *instance, VkResult error,
#define v3dv_debug_ignored_stype(sType)
#endif
const struct v3dv_format *v3dv_get_format(VkFormat);
const uint8_t *v3dv_get_format_swizzle(VkFormat f);
void v3dv_get_internal_type_bpp_for_output_format(uint32_t format, uint32_t *type, uint32_t *bpp);
const uint8_t *v3dv_get_format_swizzle(struct v3dv_device *device, VkFormat f);
uint8_t v3dv_get_tex_return_size(const struct v3dv_format *vf, bool compare_enable);
bool v3dv_tfu_supports_tex_format(const struct v3d_device_info *devinfo,
uint32_t tex_format);
const struct v3dv_format *
v3dv_get_compatible_tfu_format(const struct v3d_device_info *devinfo,
v3dv_get_compatible_tfu_format(struct v3dv_device *device,
uint32_t bpp, VkFormat *out_vk_format);
bool v3dv_buffer_format_supports_features(VkFormat vk_format,
bool v3dv_buffer_format_supports_features(struct v3dv_device *device,
VkFormat vk_format,
VkFormatFeatureFlags features);
bool v3dv_format_supports_tlb_resolve(const struct v3dv_format *format);
struct v3dv_cl_reloc v3dv_write_uniforms(struct v3dv_cmd_buffer *cmd_buffer,
struct v3dv_pipeline *pipeline,
src/broadcom/vulkan/v3dvx_formats.c
+404
View File
@@ -0,0 +1,404 @@
/*
* Copyright © 2021 Raspberry Pi
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
#include "v3dv_private.h"
#include "broadcom/common/v3d_macros.h"
#include "broadcom/cle/v3dx_pack.h"
#include "util/format/u_format.h"
#define SWIZ(x,y,z,w) { \
PIPE_SWIZZLE_##x, \
PIPE_SWIZZLE_##y, \
PIPE_SWIZZLE_##z, \
PIPE_SWIZZLE_##w \
}
#define FORMAT(vk, rt, tex, swiz, return_size, supports_filtering) \
[VK_FORMAT_##vk] = { \
true, \
V3D_OUTPUT_IMAGE_FORMAT_##rt, \
TEXTURE_DATA_FORMAT_##tex, \
swiz, \
return_size, \
supports_filtering, \
}
#define SWIZ_X001 SWIZ(X, 0, 0, 1)
#define SWIZ_XY01 SWIZ(X, Y, 0, 1)
#define SWIZ_XYZ1 SWIZ(X, Y, Z, 1)
#define SWIZ_XYZW SWIZ(X, Y, Z, W)
#define SWIZ_YZWX SWIZ(Y, Z, W, X)
#define SWIZ_YZW1 SWIZ(Y, Z, W, 1)
#define SWIZ_ZYXW SWIZ(Z, Y, X, W)
#define SWIZ_ZYX1 SWIZ(Z, Y, X, 1)
#define SWIZ_XXXY SWIZ(X, X, X, Y)
#define SWIZ_XXX1 SWIZ(X, X, X, 1)
#define SWIZ_XXXX SWIZ(X, X, X, X)
#define SWIZ_000X SWIZ(0, 0, 0, X)
#define SWIZ_WXYZ SWIZ(W, X, Y, Z)
/* FIXME: expand format table to describe whether the format is supported
* for buffer surfaces (texel buffers, vertex buffers, etc).
*/
static const struct v3dv_format format_table[] = {
/* Color, 4 channels */
FORMAT(B8G8R8A8_SRGB, SRGB8_ALPHA8, RGBA8, SWIZ_ZYXW, 16, true),
FORMAT(B8G8R8A8_UNORM, RGBA8, RGBA8, SWIZ_ZYXW, 16, true),
FORMAT(R8G8B8A8_SRGB, SRGB8_ALPHA8, RGBA8, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_UNORM, RGBA8, RGBA8, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_SNORM, NO, RGBA8_SNORM, SWIZ_XYZW, 16, true),
FORMAT(R8G8B8A8_SINT, RGBA8I, RGBA8I, SWIZ_XYZW, 16, false),
FORMAT(R8G8B8A8_UINT, RGBA8UI, RGBA8UI, SWIZ_XYZW, 16, false),
FORMAT(R16G16B16A16_SFLOAT, RGBA16F, RGBA16F, SWIZ_XYZW, 16, true),
FORMAT(R16G16B16A16_UNORM, NO, RGBA16, SWIZ_XYZW, 32, true),
FORMAT(R16G16B16A16_SNORM, NO, RGBA16_SNORM, SWIZ_XYZW, 32, true),
FORMAT(R16G16B16A16_SINT, RGBA16I, RGBA16I, SWIZ_XYZW, 16, false),
FORMAT(R16G16B16A16_UINT, RGBA16UI, RGBA16UI, SWIZ_XYZW, 16, false),
FORMAT(R32G32B32A32_SFLOAT, RGBA32F, RGBA32F, SWIZ_XYZW, 32, false),
FORMAT(R32G32B32A32_SINT, RGBA32I, RGBA32I, SWIZ_XYZW, 32, false),
FORMAT(R32G32B32A32_UINT, RGBA32UI, RGBA32UI, SWIZ_XYZW, 32, false),
/* Color, 3 channels */
FORMAT(R32G32B32_SFLOAT, NO, NO, SWIZ_XYZ1, 0, false),
FORMAT(R32G32B32_UINT, NO, NO, SWIZ_XYZ1, 0, false),
FORMAT(R32G32B32_SINT, NO, NO, SWIZ_XYZ1, 0, false),
/* Color, 2 channels */
FORMAT(R8G8_UNORM, RG8, RG8, SWIZ_XY01, 16, true),
FORMAT(R8G8_SNORM, NO, RG8_SNORM, SWIZ_XY01, 16, true),
FORMAT(R8G8_SINT, RG8I, RG8I, SWIZ_XY01, 16, false),
FORMAT(R8G8_UINT, RG8UI, RG8UI, SWIZ_XY01, 16, false),
FORMAT(R16G16_UNORM, NO, RG16, SWIZ_XY01, 32, true),
FORMAT(R16G16_SNORM, NO, RG16_SNORM, SWIZ_XY01, 32, true),
FORMAT(R16G16_SFLOAT, RG16F, RG16F, SWIZ_XY01, 16, true),
FORMAT(R16G16_SINT, RG16I, RG16I, SWIZ_XY01, 16, false),
FORMAT(R16G16_UINT, RG16UI, RG16UI, SWIZ_XY01, 16, false),
FORMAT(R32G32_SFLOAT, RG32F, RG32F, SWIZ_XY01, 32, false),
FORMAT(R32G32_SINT, RG32I, RG32I, SWIZ_XY01, 32, false),
FORMAT(R32G32_UINT, RG32UI, RG32UI, SWIZ_XY01, 32, false),
/* Color, 1 channel */
FORMAT(R8_UNORM, R8, R8, SWIZ_X001, 16, true),
FORMAT(R8_SNORM, NO, R8_SNORM, SWIZ_X001, 16, true),
FORMAT(R8_SINT, R8I, R8I, SWIZ_X001, 16, false),
FORMAT(R8_UINT, R8UI, R8UI, SWIZ_X001, 16, false),
FORMAT(R16_UNORM, NO, R16, SWIZ_X001, 32, true),
FORMAT(R16_SNORM, NO, R16_SNORM, SWIZ_X001, 32, true),
FORMAT(R16_SFLOAT, R16F, R16F, SWIZ_X001, 16, true),
FORMAT(R16_SINT, R16I, R16I, SWIZ_X001, 16, false),
FORMAT(R16_UINT, R16UI, R16UI, SWIZ_X001, 16, false),
FORMAT(R32_SFLOAT, R32F, R32F, SWIZ_X001, 32, false),
FORMAT(R32_SINT, R32I, R32I, SWIZ_X001, 32, false),
FORMAT(R32_UINT, R32UI, R32UI, SWIZ_X001, 32, false),
/* Color, packed */
FORMAT(R4G4B4A4_UNORM_PACK16, ABGR4444, RGBA4, SWIZ_XYZW, 16, true),
FORMAT(B4G4R4A4_UNORM_PACK16, ABGR4444, RGBA4, SWIZ_ZYXW, 16, true), /* Swap RB */
FORMAT(R5G6B5_UNORM_PACK16, BGR565, RGB565, SWIZ_XYZ1, 16, true),
FORMAT(R5G5B5A1_UNORM_PACK16, ABGR1555, RGB5_A1, SWIZ_XYZW, 16, true),
FORMAT(A1R5G5B5_UNORM_PACK16, RGBA5551, A1_RGB5, SWIZ_ZYXW, 16, true), /* Swap RB */
FORMAT(A8B8G8R8_UNORM_PACK32, RGBA8, RGBA8, SWIZ_XYZW, 16, true), /* RGBA8 UNORM */
FORMAT(A8B8G8R8_SNORM_PACK32, NO, RGBA8_SNORM, SWIZ_XYZW, 16, true), /* RGBA8 SNORM */
FORMAT(A8B8G8R8_UINT_PACK32, RGBA8UI, RGBA8UI, SWIZ_XYZW, 16, true), /* RGBA8 UINT */
FORMAT(A8B8G8R8_SINT_PACK32, RGBA8I, RGBA8I, SWIZ_XYZW, 16, true), /* RGBA8 SINT */
FORMAT(A8B8G8R8_SRGB_PACK32, SRGB8_ALPHA8, RGBA8, SWIZ_XYZW, 16, true), /* RGBA8 sRGB */
FORMAT(A2B10G10R10_UNORM_PACK32,RGB10_A2, RGB10_A2, SWIZ_XYZW, 16, true),
FORMAT(A2B10G10R10_UINT_PACK32, RGB10_A2UI, RGB10_A2UI, SWIZ_XYZW, 16, true),
FORMAT(E5B9G9R9_UFLOAT_PACK32, NO, RGB9_E5, SWIZ_XYZ1, 16, true),
FORMAT(B10G11R11_UFLOAT_PACK32, R11F_G11F_B10F,R11F_G11F_B10F, SWIZ_XYZ1, 16, true),
/* Depth */
FORMAT(D16_UNORM, D16, DEPTH_COMP16, SWIZ_X001, 32, false),
FORMAT(D32_SFLOAT, D32F, DEPTH_COMP32F, SWIZ_X001, 32, false),
FORMAT(X8_D24_UNORM_PACK32, D24S8, DEPTH24_X8, SWIZ_X001, 32, false),
/* Depth + Stencil */
FORMAT(D24_UNORM_S8_UINT, D24S8, DEPTH24_X8, SWIZ_X001, 32, false),
/* Compressed: ETC2 / EAC */
FORMAT(ETC2_R8G8B8_UNORM_BLOCK, NO, RGB8_ETC2, SWIZ_XYZ1, 16, true),
FORMAT(ETC2_R8G8B8_SRGB_BLOCK, NO, RGB8_ETC2, SWIZ_XYZ1, 16, true),
FORMAT(ETC2_R8G8B8A1_UNORM_BLOCK, NO, RGB8_PUNCHTHROUGH_ALPHA1, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A1_SRGB_BLOCK, NO, RGB8_PUNCHTHROUGH_ALPHA1, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A8_UNORM_BLOCK, NO, RGBA8_ETC2_EAC, SWIZ_XYZW, 16, true),
FORMAT(ETC2_R8G8B8A8_SRGB_BLOCK, NO, RGBA8_ETC2_EAC, SWIZ_XYZW, 16, true),
FORMAT(EAC_R11_UNORM_BLOCK, NO, R11_EAC, SWIZ_X001, 16, true),
FORMAT(EAC_R11_SNORM_BLOCK, NO, SIGNED_R11_EAC, SWIZ_X001, 16, true),
FORMAT(EAC_R11G11_UNORM_BLOCK, NO, RG11_EAC, SWIZ_XY01, 16, true),
FORMAT(EAC_R11G11_SNORM_BLOCK, NO, SIGNED_RG11_EAC, SWIZ_XY01, 16, true),
/* Compressed: BC1-3 */
FORMAT(BC1_RGB_UNORM_BLOCK, NO, BC1, SWIZ_XYZ1, 16, true),
FORMAT(BC1_RGB_SRGB_BLOCK, NO, BC1, SWIZ_XYZ1, 16, true),
FORMAT(BC1_RGBA_UNORM_BLOCK, NO, BC1, SWIZ_XYZW, 16, true),
FORMAT(BC1_RGBA_SRGB_BLOCK, NO, BC1, SWIZ_XYZW, 16, true),
FORMAT(BC2_UNORM_BLOCK, NO, BC2, SWIZ_XYZW, 16, true),
FORMAT(BC2_SRGB_BLOCK, NO, BC2, SWIZ_XYZW, 16, true),
FORMAT(BC3_UNORM_BLOCK, NO, BC3, SWIZ_XYZW, 16, true),
FORMAT(BC3_SRGB_BLOCK, NO, BC3, SWIZ_XYZW, 16, true),
/* Compressed: ASTC */
FORMAT(ASTC_4x4_UNORM_BLOCK, NO, ASTC_4X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_4x4_SRGB_BLOCK, NO, ASTC_4X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x4_UNORM_BLOCK, NO, ASTC_5X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x4_SRGB_BLOCK, NO, ASTC_5X4, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x5_UNORM_BLOCK, NO, ASTC_5X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_5x5_SRGB_BLOCK, NO, ASTC_5X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x5_UNORM_BLOCK, NO, ASTC_6X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x5_SRGB_BLOCK, NO, ASTC_6X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x6_UNORM_BLOCK, NO, ASTC_6X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_6x6_SRGB_BLOCK, NO, ASTC_6X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x5_UNORM_BLOCK, NO, ASTC_8X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x5_SRGB_BLOCK, NO, ASTC_8X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x6_UNORM_BLOCK, NO, ASTC_8X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x6_SRGB_BLOCK, NO, ASTC_8X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x8_UNORM_BLOCK, NO, ASTC_8X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_8x8_SRGB_BLOCK, NO, ASTC_8X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x5_UNORM_BLOCK, NO, ASTC_10X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x5_SRGB_BLOCK, NO, ASTC_10X5, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x6_UNORM_BLOCK, NO, ASTC_10X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x6_SRGB_BLOCK, NO, ASTC_10X6, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x8_UNORM_BLOCK, NO, ASTC_10X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x8_SRGB_BLOCK, NO, ASTC_10X8, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x10_UNORM_BLOCK, NO, ASTC_10X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_10x10_SRGB_BLOCK, NO, ASTC_10X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x10_UNORM_BLOCK, NO, ASTC_12X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x10_SRGB_BLOCK, NO, ASTC_12X10, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x12_UNORM_BLOCK, NO, ASTC_12X12, SWIZ_XYZW, 16, true),
FORMAT(ASTC_12x12_SRGB_BLOCK, NO, ASTC_12X12, SWIZ_XYZW, 16, true),
};
const struct v3dv_format *
v3dX(get_format)(VkFormat format)
{
if (format < ARRAY_SIZE(format_table) && format_table[format].supported)
return &format_table[format];
else
return NULL;
}
void
v3dX(get_internal_type_bpp_for_output_format)(uint32_t format,
uint32_t *type,
uint32_t *bpp)
{
switch (format) {
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8:
case V3D_OUTPUT_IMAGE_FORMAT_RGB8:
case V3D_OUTPUT_IMAGE_FORMAT_RG8:
case V3D_OUTPUT_IMAGE_FORMAT_R8:
case V3D_OUTPUT_IMAGE_FORMAT_ABGR4444:
case V3D_OUTPUT_IMAGE_FORMAT_BGR565:
case V3D_OUTPUT_IMAGE_FORMAT_ABGR1555:
*type = V3D_INTERNAL_TYPE_8;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8I:
case V3D_OUTPUT_IMAGE_FORMAT_RG8I:
case V3D_OUTPUT_IMAGE_FORMAT_R8I:
*type = V3D_INTERNAL_TYPE_8I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA8UI:
case V3D_OUTPUT_IMAGE_FORMAT_RG8UI:
case V3D_OUTPUT_IMAGE_FORMAT_R8UI:
*type = V3D_INTERNAL_TYPE_8UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_SRGB8_ALPHA8:
case V3D_OUTPUT_IMAGE_FORMAT_SRGB:
case V3D_OUTPUT_IMAGE_FORMAT_RGB10_A2:
case V3D_OUTPUT_IMAGE_FORMAT_R11F_G11F_B10F:
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16F:
/* Note that sRGB RTs are stored in the tile buffer at 16F,
* and the conversion to sRGB happens at tilebuffer load/store.
*/
*type = V3D_INTERNAL_TYPE_16F;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16F:
case V3D_OUTPUT_IMAGE_FORMAT_R16F:
*type = V3D_INTERNAL_TYPE_16F;
/* Use 64bpp to make sure the TLB doesn't throw away the alpha
* channel before alpha test happens.
*/
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16I:
*type = V3D_INTERNAL_TYPE_16I;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16I:
case V3D_OUTPUT_IMAGE_FORMAT_R16I:
*type = V3D_INTERNAL_TYPE_16I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGB10_A2UI:
case V3D_OUTPUT_IMAGE_FORMAT_RGBA16UI:
*type = V3D_INTERNAL_TYPE_16UI;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG16UI:
case V3D_OUTPUT_IMAGE_FORMAT_R16UI:
*type = V3D_INTERNAL_TYPE_16UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32I:
*type = V3D_INTERNAL_TYPE_32I;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32UI:
*type = V3D_INTERNAL_TYPE_32UI;
*bpp = V3D_INTERNAL_BPP_32;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RGBA32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_128;
break;
case V3D_OUTPUT_IMAGE_FORMAT_RG32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_64;
break;
case V3D_OUTPUT_IMAGE_FORMAT_R32F:
*type = V3D_INTERNAL_TYPE_32F;
*bpp = V3D_INTERNAL_BPP_32;
break;
default:
/* Provide some default values, as we'll be called at RB
* creation time, even if an RB with this format isn't supported.
*/
*type = V3D_INTERNAL_TYPE_8;
*bpp = V3D_INTERNAL_BPP_32;
break;
}
}
bool
v3dX(format_supports_tlb_resolve)(const struct v3dv_format *format)
{
uint32_t type, bpp;
v3dX(get_internal_type_bpp_for_output_format)(format->rt_type, &type, &bpp);
return type == V3D_INTERNAL_TYPE_8 || type == V3D_INTERNAL_TYPE_16F;
}
bool
v3dX(format_supports_blending)(const struct v3dv_format *format)
{
/* Hardware blending is only supported on render targets that are configured
* 4x8-bit unorm, 2x16-bit float or 4x16-bit float.
*/
uint32_t type, bpp;
v3dX(get_internal_type_bpp_for_output_format)(format->rt_type, &type, &bpp);
switch (type) {
case V3D_INTERNAL_TYPE_8:
return bpp == V3D_INTERNAL_BPP_32;
case V3D_INTERNAL_TYPE_16F:
return bpp == V3D_INTERNAL_BPP_32 || V3D_INTERNAL_BPP_64;
default:
return false;
}
}
bool
v3dX(tfu_supports_tex_format)(uint32_t tex_format)
{
switch (tex_format) {
case TEXTURE_DATA_FORMAT_R8:
case TEXTURE_DATA_FORMAT_R8_SNORM:
case TEXTURE_DATA_FORMAT_RG8:
case TEXTURE_DATA_FORMAT_RG8_SNORM:
case TEXTURE_DATA_FORMAT_RGBA8:
case TEXTURE_DATA_FORMAT_RGBA8_SNORM:
case TEXTURE_DATA_FORMAT_RGB565:
case TEXTURE_DATA_FORMAT_RGBA4:
case TEXTURE_DATA_FORMAT_RGB5_A1:
case TEXTURE_DATA_FORMAT_RGB10_A2:
case TEXTURE_DATA_FORMAT_R16:
case TEXTURE_DATA_FORMAT_R16_SNORM:
case TEXTURE_DATA_FORMAT_RG16:
case TEXTURE_DATA_FORMAT_RG16_SNORM:
case TEXTURE_DATA_FORMAT_RGBA16:
case TEXTURE_DATA_FORMAT_RGBA16_SNORM:
case TEXTURE_DATA_FORMAT_R16F:
case TEXTURE_DATA_FORMAT_RG16F:
case TEXTURE_DATA_FORMAT_RGBA16F:
case TEXTURE_DATA_FORMAT_R11F_G11F_B10F:
case TEXTURE_DATA_FORMAT_R4:
case TEXTURE_DATA_FORMAT_RGB9_E5:
case TEXTURE_DATA_FORMAT_R32F:
case TEXTURE_DATA_FORMAT_RG32F:
case TEXTURE_DATA_FORMAT_RGBA32F:
case TEXTURE_DATA_FORMAT_RGB8_ETC2:
case TEXTURE_DATA_FORMAT_RGB8_PUNCHTHROUGH_ALPHA1:
case TEXTURE_DATA_FORMAT_RGBA8_ETC2_EAC:
case TEXTURE_DATA_FORMAT_R11_EAC:
case TEXTURE_DATA_FORMAT_SIGNED_R11_EAC:
case TEXTURE_DATA_FORMAT_RG11_EAC:
case TEXTURE_DATA_FORMAT_SIGNED_RG11_EAC:
return true;
default:
return false;
}
}
src/broadcom/vulkan/v3dvx_pipeline.c
+1 -1
View File
@@ -110,7 +110,7 @@ pack_blend(struct v3dv_pipeline *pipeline,
VkAttachmentDescription *desc =
&pipeline->pass->attachments[attachment_idx].desc;
const struct v3dv_format *format = v3dv_get_format(desc->format);
const struct v3dv_format *format = v3dX(get_format)(desc->format);
bool dst_alpha_one = (format->swizzle[3] == PIPE_SWIZZLE_1);
uint8_t rt_mask = 1 << i;
src/broadcom/vulkan/v3dvx_private.h
+18
View File
@@ -29,6 +29,24 @@
#error This file is included by means other than v3dv_private.h
#endif
/* Used at v3dv_format */
const struct v3dv_format *
v3dX(get_format)(VkFormat);
void
v3dX(get_internal_type_bpp_for_output_format)(uint32_t format,
uint32_t *type,
uint32_t *bpp);
bool
v3dX(format_supports_tlb_resolve)(const struct v3dv_format *format);
bool
v3dX(format_supports_blending)(const struct v3dv_format *format);
bool
v3dX(tfu_supports_tex_format)(uint32_t tex_format);
/* Used at v3dv_image */
void