diff --git a/src/freedreno/vulkan/meson.build b/src/freedreno/vulkan/meson.build index e2803341476..45f9602abeb 100644 --- a/src/freedreno/vulkan/meson.build +++ b/src/freedreno/vulkan/meson.build @@ -39,15 +39,6 @@ tu_extensions_c = custom_target( ], ) -tu_format_table_c = custom_target( - 'tu_format_table.c', - input : ['vk_format_table.py', 'vk_format_layout.csv'], - output : 'vk_format_table.c', - command : [prog_python, '@INPUT@'], - depend_files : files('vk_format_parse.py'), - capture : true, -) - libtu_files = files( 'tu_blit.c', 'tu_blit.h', @@ -108,7 +99,7 @@ endif libvulkan_freedreno = shared_library( 'vulkan_freedreno', - [libtu_files, tu_entrypoints, tu_extensions_c, tu_format_table_c, freedreno_xml_header_files], + [libtu_files, tu_entrypoints, tu_extensions_c, freedreno_xml_header_files], include_directories : [ inc_common, inc_compiler, diff --git a/src/freedreno/vulkan/tu_formats.c b/src/freedreno/vulkan/tu_formats.c index a650e2f133f..909591e846b 100644 --- a/src/freedreno/vulkan/tu_formats.c +++ b/src/freedreno/vulkan/tu_formats.c @@ -323,6 +323,14 @@ tu6_get_native_format(VkFormat format) if (format >= tu6_format_table0_first && format <= tu6_format_table0_last) fmt = &tu6_format_table0[format - tu6_format_table0_first]; + if (!fmt || !fmt->present) + return NULL; + + if (vk_format_to_pipe_format(format) == PIPE_FORMAT_NONE) { + tu_finishme("vk_format %d missing matching pipe format.\n", format); + return NULL; + } + return (fmt && fmt->present) ? fmt : NULL; } @@ -499,32 +507,30 @@ union tu_clear_component_value { static uint32_t tu_pack_clear_component_value(union tu_clear_component_value val, - const struct vk_format_channel_description *ch) + const struct util_format_channel_description *ch) { uint32_t packed; switch (ch->type) { - case VK_FORMAT_TYPE_UNSIGNED: + case UTIL_FORMAT_TYPE_UNSIGNED: /* normalized, scaled, or pure integer */ - assert(ch->normalized + ch->scaled + ch->pure_integer == 1); if (ch->normalized) packed = tu_pack_float32_for_unorm(val.float32, ch->size); - else if (ch->scaled) - packed = tu_pack_float32_for_uscaled(val.float32, ch->size); - else + else if (ch->pure_integer) packed = tu_pack_uint32_for_uint(val.uint32, ch->size); + else + packed = tu_pack_float32_for_uscaled(val.float32, ch->size); break; - case VK_FORMAT_TYPE_SIGNED: + case UTIL_FORMAT_TYPE_SIGNED: /* normalized, scaled, or pure integer */ - assert(ch->normalized + ch->scaled + ch->pure_integer == 1); if (ch->normalized) packed = tu_pack_float32_for_snorm(val.float32, ch->size); - else if (ch->scaled) - packed = tu_pack_float32_for_sscaled(val.float32, ch->size); - else + else if (ch->pure_integer) packed = tu_pack_int32_for_sint(val.int32, ch->size); + else + packed = tu_pack_float32_for_sscaled(val.float32, ch->size); break; - case VK_FORMAT_TYPE_FLOAT: + case UTIL_FORMAT_TYPE_FLOAT: packed = tu_pack_float32_for_sfloat(val.float32, ch->size); break; default: @@ -537,18 +543,18 @@ tu_pack_clear_component_value(union tu_clear_component_value val, return packed; } -static const struct vk_format_channel_description * -tu_get_format_channel_description(const struct vk_format_description *desc, +static const struct util_format_channel_description * +tu_get_format_channel_description(const struct util_format_description *desc, int comp) { switch (desc->swizzle[comp]) { - case VK_SWIZZLE_X: + case PIPE_SWIZZLE_X: return &desc->channel[0]; - case VK_SWIZZLE_Y: + case PIPE_SWIZZLE_Y: return &desc->channel[1]; - case VK_SWIZZLE_Z: + case PIPE_SWIZZLE_Z: return &desc->channel[2]; - case VK_SWIZZLE_W: + case PIPE_SWIZZLE_W: return &desc->channel[3]; default: return NULL; @@ -557,20 +563,20 @@ tu_get_format_channel_description(const struct vk_format_description *desc, static union tu_clear_component_value tu_get_clear_component_value(const VkClearValue *val, int comp, - enum vk_format_colorspace colorspace) + enum util_format_colorspace colorspace) { assert(comp < 4); union tu_clear_component_value tmp; switch (colorspace) { - case VK_FORMAT_COLORSPACE_ZS: + case UTIL_FORMAT_COLORSPACE_ZS: assert(comp < 2); if (comp == 0) tmp.float32 = val->depthStencil.depth; else tmp.uint32 = val->depthStencil.stencil; break; - case VK_FORMAT_COLORSPACE_SRGB: + case UTIL_FORMAT_COLORSPACE_SRGB: if (comp < 3) { tmp.float32 = util_format_linear_to_srgb_float(val->color.float32[comp]); break; @@ -594,7 +600,7 @@ tu_get_clear_component_value(const VkClearValue *val, int comp, void tu_pack_clear_value(const VkClearValue *val, VkFormat format, uint32_t buf[4]) { - const struct vk_format_description *desc = vk_format_description(format); + const struct util_format_description *desc = vk_format_description(format); switch (format) { case VK_FORMAT_B10G11R11_UFLOAT_PACK32: @@ -607,7 +613,7 @@ tu_pack_clear_value(const VkClearValue *val, VkFormat format, uint32_t buf[4]) break; } - assert(desc && desc->layout == VK_FORMAT_LAYOUT_PLAIN); + assert(desc && desc->layout == UTIL_FORMAT_LAYOUT_PLAIN); /* S8_UINT is special and has no depth */ const int max_components = @@ -616,7 +622,7 @@ tu_pack_clear_value(const VkClearValue *val, VkFormat format, uint32_t buf[4]) int buf_offset = 0; int bit_shift = 0; for (int comp = 0; comp < max_components; comp++) { - const struct vk_format_channel_description *ch = + const struct util_format_channel_description *ch = tu_get_format_channel_description(desc, comp); if (!ch) { assert((format == VK_FORMAT_S8_UINT && comp == 0) || @@ -645,7 +651,7 @@ tu_pack_clear_value(const VkClearValue *val, VkFormat format, uint32_t buf[4]) void tu_2d_clear_color(const VkClearColorValue *val, VkFormat format, uint32_t buf[4]) { - const struct vk_format_description *desc = vk_format_description(format); + const struct util_format_description *desc = vk_format_description(format); /* not supported by 2D engine, cleared as U32 */ if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { @@ -655,10 +661,11 @@ tu_2d_clear_color(const VkClearColorValue *val, VkFormat format, uint32_t buf[4] enum a6xx_2d_ifmt ifmt = tu6_rb_fmt_to_ifmt(tu6_get_native_format(format)->rb); - assert(desc && desc->layout == VK_FORMAT_LAYOUT_PLAIN); + assert(desc && (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN || + format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)); for (unsigned i = 0; i < desc->nr_channels; i++) { - const struct vk_format_channel_description *ch = &desc->channel[i]; + const struct util_format_channel_description *ch = &desc->channel[i]; switch (ifmt) { case R2D_INT32: @@ -672,10 +679,10 @@ tu_2d_clear_color(const VkClearColorValue *val, VkFormat format, uint32_t buf[4] break; case R2D_UNORM8: { float linear = val->float32[i]; - if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB && i < 3) + if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB && i < 3) linear = util_format_linear_to_srgb_float(val->float32[i]); - if (ch->type == VK_FORMAT_TYPE_SIGNED) + if (ch->type == UTIL_FORMAT_TYPE_SIGNED) buf[i] = tu_pack_float32_for_snorm(linear, 8); else buf[i] = tu_pack_float32_for_unorm(linear, 8); @@ -718,7 +725,7 @@ tu_physical_device_get_format_properties( VkFormatProperties *out_properties) { VkFormatFeatureFlags linear = 0, tiled = 0, buffer = 0; - const struct vk_format_description *desc = vk_format_description(format); + const struct util_format_description *desc = vk_format_description(format); const struct tu_native_format *native_fmt = tu6_get_native_format(format); if (!desc || !native_fmt) { goto end; diff --git a/src/freedreno/vulkan/tu_image.c b/src/freedreno/vulkan/tu_image.c index 6c774de9f53..0b14a28d44d 100644 --- a/src/freedreno/vulkan/tu_image.c +++ b/src/freedreno/vulkan/tu_image.c @@ -74,7 +74,7 @@ static void setup_slices(struct tu_image *image, const VkImageCreateInfo *pCreateInfo) { VkFormat format = pCreateInfo->format; - enum vk_format_layout layout = vk_format_description(format)->layout; + enum util_format_layout layout = vk_format_description(format)->layout; uint32_t layer_size = 0; int ta = image->cpp; @@ -113,7 +113,7 @@ setup_slices(struct tu_image *image, const VkImageCreateInfo *pCreateInfo) if (level + 1 == pCreateInfo->mipLevels) aligned_height = align(aligned_height, 32); - if (layout == VK_FORMAT_LAYOUT_ASTC) + if (layout == UTIL_FORMAT_LAYOUT_ASTC) slice->pitch = util_align_npot(width, pitchalign * vk_format_get_blockwidth(format)); else @@ -218,7 +218,7 @@ tu_image_create(VkDevice _device, static enum a6xx_tex_fetchsize tu6_fetchsize(VkFormat format) { - if (vk_format_description(format)->layout == VK_FORMAT_LAYOUT_ASTC) + if (vk_format_description(format)->layout == UTIL_FORMAT_LAYOUT_ASTC) return TFETCH6_16_BYTE; switch (vk_format_get_blocksize(format) / vk_format_get_blockwidth(format)) { @@ -249,8 +249,8 @@ tu6_texswiz(const VkComponentMapping *comps, const unsigned char *fmt_swiz) /* if format has 0/1 in channel, use that (needed for bc1_rgb) */ if (swiz[i] < 4) { switch (fmt_swiz[swiz[i]]) { - case VK_SWIZZLE_0: swiz[i] = A6XX_TEX_ZERO; break; - case VK_SWIZZLE_1: swiz[i] = A6XX_TEX_ONE; break; + case PIPE_SWIZZLE_0: swiz[i] = A6XX_TEX_ZERO; break; + case PIPE_SWIZZLE_1: swiz[i] = A6XX_TEX_ONE; break; } } } diff --git a/src/freedreno/vulkan/vk_format.h b/src/freedreno/vulkan/vk_format.h index bbf7a5d81b9..b1b763ff52e 100644 --- a/src/freedreno/vulkan/vk_format.h +++ b/src/freedreno/vulkan/vk_format.h @@ -29,120 +29,16 @@ #include #include +#include +#include #include -enum vk_format_layout +static inline const struct util_format_description * +vk_format_description(VkFormat format) { - /** - * Formats with vk_format_block::width == vk_format_block::height == 1 - * that can be described as an ordinary data structure. - */ - VK_FORMAT_LAYOUT_PLAIN = 0, - - /** - * Formats with sub-sampled channels. - * - * This is for formats like YVYU where there is less than one sample per - * pixel. - */ - VK_FORMAT_LAYOUT_SUBSAMPLED = 3, - - /** - * S3 Texture Compression formats. - */ - VK_FORMAT_LAYOUT_S3TC = 4, - - /** - * Red-Green Texture Compression formats. - */ - VK_FORMAT_LAYOUT_RGTC = 5, - - /** - * Ericsson Texture Compression - */ - VK_FORMAT_LAYOUT_ETC = 6, - - /** - * BC6/7 Texture Compression - */ - VK_FORMAT_LAYOUT_BPTC = 7, - - /** - * ASTC - */ - VK_FORMAT_LAYOUT_ASTC = 8, - - /** - * Everything else that doesn't fit in any of the above layouts. - */ - VK_FORMAT_LAYOUT_OTHER = 9 -}; - -struct vk_format_block -{ - /** Block width in pixels */ - unsigned width; - - /** Block height in pixels */ - unsigned height; - - /** Block size in bits */ - unsigned bits; -}; - -enum vk_format_type -{ - VK_FORMAT_TYPE_VOID = 0, - VK_FORMAT_TYPE_UNSIGNED = 1, - VK_FORMAT_TYPE_SIGNED = 2, - VK_FORMAT_TYPE_FIXED = 3, - VK_FORMAT_TYPE_FLOAT = 4 -}; - -enum vk_format_colorspace -{ - VK_FORMAT_COLORSPACE_RGB = 0, - VK_FORMAT_COLORSPACE_SRGB = 1, - VK_FORMAT_COLORSPACE_YUV = 2, - VK_FORMAT_COLORSPACE_ZS = 3 -}; - -struct vk_format_channel_description -{ - unsigned type : 5; - unsigned normalized : 1; - unsigned pure_integer : 1; - unsigned scaled : 1; - unsigned size : 8; - unsigned shift : 16; -}; - -struct vk_format_description -{ - VkFormat format; - const char *name; - const char *short_name; - - struct vk_format_block block; - enum vk_format_layout layout; - - unsigned nr_channels : 3; - unsigned is_array : 1; - unsigned is_bitmask : 1; - unsigned is_mixed : 1; - - struct vk_format_channel_description channel[4]; - - unsigned char swizzle[4]; - - enum vk_format_colorspace colorspace; -}; - -extern const struct vk_format_description vk_format_description_table[]; - -const struct vk_format_description * -vk_format_description(VkFormat format); + return util_format_description(vk_format_to_pipe_format(format)); +} /** * Return total bits needed for the pixel format per block. @@ -150,14 +46,7 @@ vk_format_description(VkFormat format); static inline unsigned vk_format_get_blocksizebits(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return 0; - } - - return desc->block.bits; + return util_format_get_blocksizebits(vk_format_to_pipe_format(format)); } /** @@ -166,97 +55,40 @@ vk_format_get_blocksizebits(VkFormat format) static inline unsigned vk_format_get_blocksize(VkFormat format) { - unsigned bits = vk_format_get_blocksizebits(format); - unsigned bytes = bits / 8; - - assert(bits % 8 == 0); - assert(bytes > 0); - if (bytes == 0) { - bytes = 1; - } - - return bytes; + return util_format_get_blocksize(vk_format_to_pipe_format(format)); } static inline unsigned vk_format_get_blockwidth(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return 1; - } - - return desc->block.width; + return util_format_get_blockwidth(vk_format_to_pipe_format(format)); } static inline unsigned vk_format_get_blockheight(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return 1; - } - - return desc->block.height; + return util_format_get_blockheight(vk_format_to_pipe_format(format)); } static inline unsigned vk_format_get_block_count_width(VkFormat format, unsigned width) { - unsigned blockwidth = vk_format_get_blockwidth(format); - return (width + blockwidth - 1) / blockwidth; + return util_format_get_nblocksx(vk_format_to_pipe_format(format), width); } static inline unsigned vk_format_get_block_count_height(VkFormat format, unsigned height) { - unsigned blockheight = vk_format_get_blockheight(format); - return (height + blockheight - 1) / blockheight; + return util_format_get_nblocksy(vk_format_to_pipe_format(format), height); } static inline unsigned vk_format_get_block_count(VkFormat format, unsigned width, unsigned height) { - return vk_format_get_block_count_width(format, width) * - vk_format_get_block_count_height(format, height); + return util_format_get_nblocks(vk_format_to_pipe_format(format), + width, height); } -/** - * Return the index of the first non-void channel - * -1 if no non-void channels - */ -static inline int -vk_format_get_first_non_void_channel(VkFormat format) -{ - const struct vk_format_description *desc = vk_format_description(format); - int i; - - for (i = 0; i < 4; i++) - if (desc->channel[i].type != VK_FORMAT_TYPE_VOID) - break; - - if (i == 4) - return -1; - - return i; -} - -enum vk_swizzle -{ - VK_SWIZZLE_X, - VK_SWIZZLE_Y, - VK_SWIZZLE_Z, - VK_SWIZZLE_W, - VK_SWIZZLE_0, - VK_SWIZZLE_1, - VK_SWIZZLE_NONE, - VK_SWIZZLE_MAX, /**< Number of enums counter (must be last) */ -}; - static inline VkImageAspectFlags vk_format_aspects(VkFormat format) { @@ -282,7 +114,7 @@ vk_format_aspects(VkFormat format) } } -static inline enum vk_swizzle +static inline enum pipe_swizzle tu_swizzle_conv(VkComponentSwizzle component, const unsigned char chan[4], VkComponentSwizzle vk_swiz) @@ -293,29 +125,29 @@ tu_swizzle_conv(VkComponentSwizzle component, vk_swiz = component; switch (vk_swiz) { case VK_COMPONENT_SWIZZLE_ZERO: - return VK_SWIZZLE_0; + return PIPE_SWIZZLE_0; case VK_COMPONENT_SWIZZLE_ONE: - return VK_SWIZZLE_1; + return PIPE_SWIZZLE_1; case VK_COMPONENT_SWIZZLE_R: for (x = 0; x < 4; x++) if (chan[x] == 0) return x; - return VK_SWIZZLE_0; + return PIPE_SWIZZLE_0; case VK_COMPONENT_SWIZZLE_G: for (x = 0; x < 4; x++) if (chan[x] == 1) return x; - return VK_SWIZZLE_0; + return PIPE_SWIZZLE_0; case VK_COMPONENT_SWIZZLE_B: for (x = 0; x < 4; x++) if (chan[x] == 2) return x; - return VK_SWIZZLE_0; + return PIPE_SWIZZLE_0; case VK_COMPONENT_SWIZZLE_A: for (x = 0; x < 4; x++) if (chan[x] == 3) return x; - return VK_SWIZZLE_1; + return PIPE_SWIZZLE_1; default: unreachable("Illegal swizzle"); } @@ -324,7 +156,7 @@ tu_swizzle_conv(VkComponentSwizzle component, static inline void vk_format_compose_swizzles(const VkComponentMapping *mapping, const unsigned char swz[4], - enum vk_swizzle dst[4]) + enum pipe_swizzle dst[4]) { dst[0] = tu_swizzle_conv(VK_COMPONENT_SWIZZLE_R, swz, mapping->r); dst[1] = tu_swizzle_conv(VK_COMPONENT_SWIZZLE_G, swz, mapping->g); @@ -335,77 +167,29 @@ vk_format_compose_swizzles(const VkComponentMapping *mapping, static inline bool vk_format_is_compressed(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return false; - } - - switch (desc->layout) { - case VK_FORMAT_LAYOUT_S3TC: - case VK_FORMAT_LAYOUT_RGTC: - case VK_FORMAT_LAYOUT_ETC: - case VK_FORMAT_LAYOUT_BPTC: - case VK_FORMAT_LAYOUT_ASTC: - /* XXX add other formats in the future */ - return true; - default: - return false; - } + return util_format_is_compressed(vk_format_to_pipe_format(format)); } static inline bool -vk_format_has_depth(const struct vk_format_description *desc) +vk_format_has_depth(VkFormat format) { - return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && - desc->swizzle[0] != VK_SWIZZLE_NONE; + const struct util_format_description *desc = vk_format_description(format); + + return util_format_has_depth(desc); } static inline bool -vk_format_has_stencil(const struct vk_format_description *desc) +vk_format_has_stencil(VkFormat format) { - return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && - desc->swizzle[1] != VK_SWIZZLE_NONE; + const struct util_format_description *desc = vk_format_description(format); + + return util_format_has_stencil(desc); } static inline bool vk_format_is_depth_or_stencil(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return false; - } - - return vk_format_has_depth(desc) || vk_format_has_stencil(desc); -} - -static inline bool -vk_format_is_depth(VkFormat format) -{ - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return false; - } - - return vk_format_has_depth(desc); -} - -static inline bool -vk_format_is_stencil(VkFormat format) -{ - const struct vk_format_description *desc = vk_format_description(format); - - assert(desc); - if (!desc) { - return false; - } - - return vk_format_has_stencil(desc); + return vk_format_has_depth(format) || vk_format_has_stencil(format); } static inline bool @@ -417,11 +201,7 @@ vk_format_is_color(VkFormat format) static inline bool vk_format_has_alpha(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - - return (desc->colorspace == VK_FORMAT_COLORSPACE_RGB || - desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) && - desc->swizzle[3] != VK_SWIZZLE_1; + return util_format_has_alpha(vk_format_to_pipe_format(format)); } static inline VkFormat @@ -442,39 +222,25 @@ vk_format_depth_only(VkFormat format) static inline bool vk_format_is_int(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - int channel = vk_format_get_first_non_void_channel(format); - - return channel >= 0 && desc->channel[channel].pure_integer; + return util_format_is_pure_integer(vk_format_to_pipe_format(format)); } static inline bool vk_format_is_uint(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - int channel = vk_format_get_first_non_void_channel(format); - - return channel >= 0 && - desc->channel[channel].pure_integer && - desc->channel[channel].type != VK_FORMAT_TYPE_SIGNED; + return util_format_is_pure_uint(vk_format_to_pipe_format(format)); } static inline bool vk_format_is_sint(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - int channel = vk_format_get_first_non_void_channel(format); - - return channel >= 0 && - desc->channel[channel].pure_integer && - desc->channel[channel].type == VK_FORMAT_TYPE_SIGNED; + return util_format_is_pure_sint(vk_format_to_pipe_format(format)); } static inline bool vk_format_is_srgb(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - return desc->colorspace == VK_FORMAT_COLORSPACE_SRGB; + return util_format_is_srgb(vk_format_to_pipe_format(format)); } static inline VkFormat @@ -525,75 +291,17 @@ vk_format_stencil_only(VkFormat format) static inline unsigned vk_format_get_component_bits(VkFormat format, - enum vk_format_colorspace colorspace, + enum util_format_colorspace colorspace, unsigned component) { - const struct vk_format_description *desc = vk_format_description(format); - enum vk_format_colorspace desc_colorspace; - - assert(format); - if (!format) { - return 0; - } - - assert(component < 4); - - /* Treat RGB and SRGB as equivalent. */ - if (colorspace == VK_FORMAT_COLORSPACE_SRGB) { - colorspace = VK_FORMAT_COLORSPACE_RGB; - } - if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) { - desc_colorspace = VK_FORMAT_COLORSPACE_RGB; - } else { - desc_colorspace = desc->colorspace; - } - - if (desc_colorspace != colorspace) { - return 0; - } - - switch (desc->swizzle[component]) { - case VK_SWIZZLE_X: - return desc->channel[0].size; - case VK_SWIZZLE_Y: - return desc->channel[1].size; - case VK_SWIZZLE_Z: - return desc->channel[2].size; - case VK_SWIZZLE_W: - return desc->channel[3].size; - default: - return 0; - } -} - -static inline VkFormat -vk_to_non_srgb_format(VkFormat format) -{ - switch (format) { - case VK_FORMAT_R8_SRGB: - return VK_FORMAT_R8_UNORM; - case VK_FORMAT_R8G8_SRGB: - return VK_FORMAT_R8G8_UNORM; - case VK_FORMAT_R8G8B8_SRGB: - return VK_FORMAT_R8G8B8_UNORM; - case VK_FORMAT_B8G8R8_SRGB: - return VK_FORMAT_B8G8R8_UNORM; - case VK_FORMAT_R8G8B8A8_SRGB: - return VK_FORMAT_R8G8B8A8_UNORM; - case VK_FORMAT_B8G8R8A8_SRGB: - return VK_FORMAT_B8G8R8A8_UNORM; - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: - return VK_FORMAT_A8B8G8R8_UNORM_PACK32; - default: - return format; - } + return util_format_get_component_bits(vk_format_to_pipe_format(format), + colorspace, component); } static inline unsigned vk_format_get_nr_components(VkFormat format) { - const struct vk_format_description *desc = vk_format_description(format); - return desc->nr_channels; + return util_format_get_nr_components(vk_format_to_pipe_format(format)); } #endif /* VK_FORMAT_H */ diff --git a/src/freedreno/vulkan/vk_format_layout.csv b/src/freedreno/vulkan/vk_format_layout.csv deleted file mode 100644 index 9e85ff5d258..00000000000 --- a/src/freedreno/vulkan/vk_format_layout.csv +++ /dev/null @@ -1,188 +0,0 @@ -/* this is pretty much taken from the gallium one. */ - - -VK_FORMAT_UNDEFINED , plain, 1, 1, u8 , , , , x001, rgb -VK_FORMAT_R4G4_UNORM_PACK8 , plain, 1, 1, un4 , un4 , , , xy01, rgb -VK_FORMAT_R4G4B4A4_UNORM_PACK16 , plain, 1, 1, un4 , un4 , un4 , un4 , wzyx, rgb -VK_FORMAT_B4G4R4A4_UNORM_PACK16 , plain, 1, 1, un4 , un4 , un4 , un4 , wxyz, rgb -VK_FORMAT_R5G6B5_UNORM_PACK16 , plain, 1, 1, un5 , un6 , un5 , , zyx1, rgb -VK_FORMAT_B5G6R5_UNORM_PACK16 , plain, 1, 1, un5 , un6 , un5 , , xyz1, rgb -VK_FORMAT_R5G5B5A1_UNORM_PACK16 , plain, 1, 1, un1 , un5 , un5 , un5 , wzyx, rgb -VK_FORMAT_B5G5R5A1_UNORM_PACK16 , plain, 1, 1, un1 , un5 , un5 , un5 , wxyz, rgb -VK_FORMAT_A1R5G5B5_UNORM_PACK16 , plain, 1, 1, un5 , un5 , un5 , un1 , zyxw, rgb -VK_FORMAT_R8_UNORM , plain, 1, 1, un8 , , , , x001, rgb -VK_FORMAT_R8_SNORM , plain, 1, 1, sn8 , , , , x001, rgb -VK_FORMAT_R8_USCALED , plain, 1, 1, us8 , , , , x001, rgb -VK_FORMAT_R8_SSCALED , plain, 1, 1, ss8 , , , , x001, rgb -VK_FORMAT_R8_UINT , plain, 1, 1, up8 , , , , x001, rgb -VK_FORMAT_R8_SINT , plain, 1, 1, sp8 , , , , x001, rgb -VK_FORMAT_R8_SRGB , plain, 1, 1, un8 , , , , x001, srgb -VK_FORMAT_R8G8_UNORM , plain, 1, 1, un8 , un8 , , , xy01, rgb -VK_FORMAT_R8G8_SNORM , plain, 1, 1, sn8 , sn8 , , , xy01, rgb -VK_FORMAT_R8G8_USCALED , plain, 1, 1, us8 , us8 , , , xy01, rgb -VK_FORMAT_R8G8_SSCALED , plain, 1, 1, ss8 , ss8 , , , xy01, rgb -VK_FORMAT_R8G8_UINT , plain, 1, 1, up8 , up8 , , , xy01, rgb -VK_FORMAT_R8G8_SINT , plain, 1, 1, sp8 , sp8 , , , xy01, rgb -VK_FORMAT_R8G8_SRGB , plain, 1, 1, un8 , un8 , , , xy01, srgb -VK_FORMAT_R8G8B8_UNORM , plain, 1, 1, un8 , un8 , un8 , , xyz1, rgb -VK_FORMAT_R8G8B8_SNORM , plain, 1, 1, sn8 , sn8 , sn8 , , xyz1, rgb -VK_FORMAT_R8G8B8_USCALED , plain, 1, 1, us8 , us8 , us8 , , xyz1, rgb -VK_FORMAT_R8G8B8_SSCALED , plain, 1, 1, ss8 , ss8 , ss8 , , xyz1, rgb -VK_FORMAT_R8G8B8_UINT , plain, 1, 1, up8 , up8 , up8 , , xyz1, rgb -VK_FORMAT_R8G8B8_SINT , plain, 1, 1, sp8 , sp8 , sp8 , , xyz1, rgb -VK_FORMAT_R8G8B8_SRGB , plain, 1, 1, un8 , un8 , un8 , , xyz1, srgb -VK_FORMAT_B8G8R8_UNORM , plain, 1, 1, un8 , un8 , un8 , , zyx1, rgb -VK_FORMAT_B8G8R8_SNORM , plain, 1, 1, sn8 , sn8 , sn8 , , zyx1, rgb -VK_FORMAT_B8G8R8_USCALED , plain, 1, 1, us8 , us8 , us8 , , zyx1, rgb -VK_FORMAT_B8G8R8_SSCALED , plain, 1, 1, ss8 , ss8 , ss8 , , zyx1, rgb -VK_FORMAT_B8G8R8_UINT , plain, 1, 1, up8 , up8 , up8 , , zyx1, rgb -VK_FORMAT_B8G8R8_SINT , plain, 1, 1, sp8 , sp8 , sp8 , , zyx1, rgb -VK_FORMAT_B8G8R8_SRGB , plain, 1, 1, un8 , un8 , un8 , , zyx1, srgb -VK_FORMAT_R8G8B8A8_UNORM , plain, 1, 1, un8 , un8 , un8 , un8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_SNORM , plain, 1, 1, sn8 , sn8 , sn8 , sn8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_USCALED , plain, 1, 1, us8 , us8 , us8 , us8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_SSCALED , plain, 1, 1, ss8 , ss8 , ss8 , ss8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_UINT , plain, 1, 1, up8 , up8 , up8 , up8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_SINT , plain, 1, 1, sp8 , sp8 , sp8 , sp8 , xyzw, rgb -VK_FORMAT_R8G8B8A8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , xyzw, srgb -VK_FORMAT_B8G8R8A8_UNORM , plain, 1, 1, un8 , un8 , un8 , un8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_SNORM , plain, 1, 1, sn8 , sn8 , sn8 , sn8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_USCALED , plain, 1, 1, us8 , us8 , us8 , us8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_SSCALED , plain, 1, 1, ss8 , ss8 , ss8 , ss8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_UINT , plain, 1, 1, up8 , up8 , up8 , up8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_SINT , plain, 1, 1, sp8 , sp8 , sp8 , sp8 , zyxw, rgb -VK_FORMAT_B8G8R8A8_SRGB , plain, 1, 1, un8 , un8 , un8 , un8 , zyxw, srgb -VK_FORMAT_A8B8G8R8_UNORM_PACK32 , plain, 1, 1, un8 , un8 , un8 , un8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_SNORM_PACK32 , plain, 1, 1, sn8 , sn8 , sn8 , sn8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_USCALED_PACK32 , plain, 1, 1, us8 , us8 , us8 , us8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_SSCALED_PACK32 , plain, 1, 1, ss8 , ss8 , ss8 , ss8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_UINT_PACK32 , plain, 1, 1, up8 , up8 , up8 , up8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_SINT_PACK32 , plain, 1, 1, sp8 , sp8 , sp8 , sp8 , xyzw, rgb -VK_FORMAT_A8B8G8R8_SRGB_PACK32 , plain, 1, 1, un8 , un8 , un8 , un8 , xyzw, srgb -VK_FORMAT_A2R10G10B10_UNORM_PACK32 , plain, 1, 1, un10, un10, un10, un2 , zyxw, rgb -VK_FORMAT_A2R10G10B10_SNORM_PACK32 , plain, 1, 1, sn10, sn10, sn10, sn2 , zyxw, rgb -VK_FORMAT_A2R10G10B10_USCALED_PACK32 , plain, 1, 1, us10, us10, us10, us2 , zyxw, rgb -VK_FORMAT_A2R10G10B10_SSCALED_PACK32 , plain, 1, 1, ss10, ss10, ss10, ss2 , zyxw, rgb -VK_FORMAT_A2R10G10B10_UINT_PACK32 , plain, 1, 1, up10, up10, up10, up2 , zyxw, rgb -VK_FORMAT_A2R10G10B10_SINT_PACK32 , plain, 1, 1, sp10, sp10, sp10, sp2 , zyxw, rgb -VK_FORMAT_A2B10G10R10_UNORM_PACK32 , plain, 1, 1, un10, un10, un10, un2 , xyzw, rgb -VK_FORMAT_A2B10G10R10_SNORM_PACK32 , plain, 1, 1, sn10, sn10, sn10, sn2 , xyzw, rgb -VK_FORMAT_A2B10G10R10_USCALED_PACK32 , plain, 1, 1, us10, us10, us10, us2 , xyzw, rgb -VK_FORMAT_A2B10G10R10_SSCALED_PACK32 , plain, 1, 1, ss10, ss10, ss10, ss2 , xyzw, rgb -VK_FORMAT_A2B10G10R10_UINT_PACK32 , plain, 1, 1, up10, up10, up10, up2 , xyzw, rgb -VK_FORMAT_A2B10G10R10_SINT_PACK32 , plain, 1, 1, sp10, sp10, sp10, sp2 , xyzw, rgb -VK_FORMAT_R16_UNORM , plain, 1, 1, un16, , , , x001, rgb -VK_FORMAT_R16_SNORM , plain, 1, 1, sn16, , , , x001, rgb -VK_FORMAT_R16_USCALED , plain, 1, 1, us16, , , , x001, rgb -VK_FORMAT_R16_SSCALED , plain, 1, 1, ss16, , , , x001, rgb -VK_FORMAT_R16_UINT , plain, 1, 1, up16, , , , x001, rgb -VK_FORMAT_R16_SINT , plain, 1, 1, sp16, , , , x001, rgb -VK_FORMAT_R16_SFLOAT , plain, 1, 1, f16 , , , , x001, rgb -VK_FORMAT_R16G16_UNORM , plain, 1, 1, un16, un16, , , xy01, rgb -VK_FORMAT_R16G16_SNORM , plain, 1, 1, sn16, sn16, , , xy01, rgb -VK_FORMAT_R16G16_USCALED , plain, 1, 1, us16, us16, , , xy01, rgb -VK_FORMAT_R16G16_SSCALED , plain, 1, 1, ss16, ss16, , , xy01, rgb -VK_FORMAT_R16G16_UINT , plain, 1, 1, up16, up16, , , xy01, rgb -VK_FORMAT_R16G16_SINT , plain, 1, 1, sp16, sp16, , , xy01, rgb -VK_FORMAT_R16G16_SFLOAT , plain, 1, 1, f16 , f16 , , , xy01, rgb -VK_FORMAT_R16G16B16_UNORM , plain, 1, 1, un16, un16, un16, , xyz1, rgb -VK_FORMAT_R16G16B16_SNORM , plain, 1, 1, sn16, sn16, sn16, , xyz1, rgb -VK_FORMAT_R16G16B16_USCALED , plain, 1, 1, us16, us16, us16, , xyz1, rgb -VK_FORMAT_R16G16B16_SSCALED , plain, 1, 1, ss16, ss16, ss16, , xyz1, rgb -VK_FORMAT_R16G16B16_UINT , plain, 1, 1, up16, up16, up16, , xyz1, rgb -VK_FORMAT_R16G16B16_SINT , plain, 1, 1, sp16, sp16, sp16, , xyz1, rgb -VK_FORMAT_R16G16B16_SFLOAT , plain, 1, 1, f16 , f16 , f16 , , xyz1, rgb -VK_FORMAT_R16G16B16A16_UNORM , plain, 1, 1, un16, un16, un16, un16, xyzw, rgb -VK_FORMAT_R16G16B16A16_SNORM , plain, 1, 1, sn16, sn16, sn16, sn16, xyzw, rgb -VK_FORMAT_R16G16B16A16_USCALED , plain, 1, 1, us16, us16, us16, us16, xyzw, rgb -VK_FORMAT_R16G16B16A16_SSCALED , plain, 1, 1, ss16, ss16, ss16, ss16, xyzw, rgb -VK_FORMAT_R16G16B16A16_UINT , plain, 1, 1, up16, up16, up16, up16, xyzw, rgb -VK_FORMAT_R16G16B16A16_SINT , plain, 1, 1, sp16, sp16, sp16, sp16, xyzw, rgb -VK_FORMAT_R16G16B16A16_SFLOAT , plain, 1, 1, f16 , f16 , f16 , f16 , xyzw, rgb -VK_FORMAT_R32_UINT , plain, 1, 1, up32, , , , x001, rgb -VK_FORMAT_R32_SINT , plain, 1, 1, sp32, , , , x001, rgb -VK_FORMAT_R32_SFLOAT , plain, 1, 1, f32 , , , , x001, rgb -VK_FORMAT_R32G32_UINT , plain, 1, 1, up32, up32, , , xy01, rgb -VK_FORMAT_R32G32_SINT , plain, 1, 1, sp32, sp32, , , xy01, rgb -VK_FORMAT_R32G32_SFLOAT , plain, 1, 1, f32 , f32 , , , xy01, rgb -VK_FORMAT_R32G32B32_UINT , plain, 1, 1, up32, up32, up32, , xyz1, rgb -VK_FORMAT_R32G32B32_SINT , plain, 1, 1, sp32, sp32, sp32, , xyz1, rgb -VK_FORMAT_R32G32B32_SFLOAT , plain, 1, 1, f32 , f32 , f32 , , xyz1, rgb -VK_FORMAT_R32G32B32A32_UINT , plain, 1, 1, up32, up32, up32, up32, xyzw, rgb -VK_FORMAT_R32G32B32A32_SINT , plain, 1, 1, sp32, sp32, sp32, sp32, xyzw, rgb -VK_FORMAT_R32G32B32A32_SFLOAT , plain, 1, 1, f32 , f32 , f32 , f32 , xyzw, rgb -VK_FORMAT_R64_UINT , plain, 1, 1, up64, , , , x001, rgb -VK_FORMAT_R64_SINT , plain, 1, 1, sp64, , , , x001, rgb -VK_FORMAT_R64_SFLOAT , plain, 1, 1, f64 , , , , x001, rgb -VK_FORMAT_R64G64_UINT , plain, 1, 1, up64, up64, , , xy01, rgb -VK_FORMAT_R64G64_SINT , plain, 1, 1, sp64, sp64, , , xy01, rgb -VK_FORMAT_R64G64_SFLOAT , plain, 1, 1, f64 , f64 , , , xy01, rgb -VK_FORMAT_R64G64B64_UINT , plain, 1, 1, up64, up64, up64, , xyz1, rgb -VK_FORMAT_R64G64B64_SINT , plain, 1, 1, sp64, sp64, sp64, , xyz1, rgb -VK_FORMAT_R64G64B64_SFLOAT , plain, 1, 1, f64 , f64 , f64 , , xyz1, rgb -VK_FORMAT_R64G64B64A64_UINT , plain, 1, 1, up64, up64, up64, up64, xyzw, rgb -VK_FORMAT_R64G64B64A64_SINT , plain, 1, 1, sp64, sp64, sp64, sp64, xyzw, rgb -VK_FORMAT_R64G64B64A64_SFLOAT , plain, 1, 1, f64 , f64 , f64 , f64 , xyzw, rgb -VK_FORMAT_B10G11R11_UFLOAT_PACK32 , plain, 1, 1, f10 , f11 , f11 , , xyz1, rgb -VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 , other, 1, 1, x32 , , , , xyz1, rgb -VK_FORMAT_D16_UNORM , plain, 1, 1, un16, , , , x___, zs -VK_FORMAT_X8_D24_UNORM_PACK32 , plain, 1, 1, un24, x8 , , , x___, zs -VK_FORMAT_D32_SFLOAT , plain, 1, 1, f32 , , , , x___, zs -VK_FORMAT_S8_UINT , plain, 1, 1, up8 , , , , _x__, zs -VK_FORMAT_D16_UNORM_S8_UINT , plain, 1, 1, un16, up8 , , , xy__, zs -VK_FORMAT_D24_UNORM_S8_UINT , plain, 1, 1, un24, up8 , , , xy__, zs -VK_FORMAT_D32_SFLOAT_S8_UINT , plain, 1, 1, f32 , up8 , , , xy__, zs -VK_FORMAT_BC1_RGB_UNORM_BLOCK , s3tc, 4, 4, x64 , , , , xyz1, rgb -VK_FORMAT_BC1_RGB_SRGB_BLOCK , s3tc, 4, 4, x64 , , , , xyz1, srgb -VK_FORMAT_BC1_RGBA_UNORM_BLOCK , s3tc, 4, 4, x64 , , , , xyzw, rgb -VK_FORMAT_BC1_RGBA_SRGB_BLOCK , s3tc, 4, 4, x64 , , , , xyzw, srgb -VK_FORMAT_BC2_UNORM_BLOCK , s3tc, 4, 4, x128, , , , xyzw, rgb -VK_FORMAT_BC2_SRGB_BLOCK , s3tc, 4, 4, x128, , , , xyzw, srgb -VK_FORMAT_BC3_UNORM_BLOCK , s3tc, 4, 4, x128, , , , xyzw, rgb -VK_FORMAT_BC3_SRGB_BLOCK , s3tc, 4, 4, x128, , , , xyzw, srgb -VK_FORMAT_BC4_UNORM_BLOCK , rgtc, 4, 4, x64, , , , x001, rgb -VK_FORMAT_BC4_SNORM_BLOCK , rgtc, 4, 4, x64, , , , x001, rgb -VK_FORMAT_BC5_UNORM_BLOCK , rgtc, 4, 4, x128, , , , xy01, rgb -VK_FORMAT_BC5_SNORM_BLOCK , rgtc, 4, 4, x128, , , , xy01, rgb -VK_FORMAT_BC6H_UFLOAT_BLOCK , bptc, 4, 4, x128, , , , xyz1, rgb -VK_FORMAT_BC6H_SFLOAT_BLOCK , bptc, 4, 4, x128, , , , xyz1, rgb -VK_FORMAT_BC7_UNORM_BLOCK , bptc, 4, 4, x128, , , , xyzw, rgb -VK_FORMAT_BC7_SRGB_BLOCK , bptc, 4, 4, x128, , , , xyzw, srgb -VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK , etc, 4, 4, x64, , , , xyz1, rgb -VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK , etc, 4, 4, x64, , , , xyz1, srgb -VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK , etc, 4, 4, x64, , , , xyzw, rgb -VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK , etc, 4, 4, x64, , , , xyzw, srgb -VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK , etc, 4, 4, x128, , , , xyzw, rgb -VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK , etc, 4, 4, x128, , , , xyzw, srgb -VK_FORMAT_EAC_R11_UNORM_BLOCK , etc, 4, 4, x64, , , , x001, rgb -VK_FORMAT_EAC_R11_SNORM_BLOCK , etc, 4, 4, x64, , , , x001, rgb -VK_FORMAT_EAC_R11G11_UNORM_BLOCK , etc, 4, 4, x128, , , , xy01, rgb -VK_FORMAT_EAC_R11G11_SNORM_BLOCK , etc, 4, 4, x128, , , , xy01, rgb -VK_FORMAT_ASTC_4x4_UNORM_BLOCK , astc, 4, 4, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_5x4_UNORM_BLOCK , astc, 5, 4, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_5x5_UNORM_BLOCK , astc, 5, 5, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_6x5_UNORM_BLOCK , astc, 6, 5, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_6x6_UNORM_BLOCK , astc, 6, 6, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_8x5_UNORM_BLOCK , astc, 8, 5, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_8x6_UNORM_BLOCK , astc, 8, 6, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_8x8_UNORM_BLOCK , astc, 8, 8, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_10x5_UNORM_BLOCK , astc, 10, 5, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_10x6_UNORM_BLOCK , astc, 10, 6, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_10x8_UNORM_BLOCK , astc, 10, 8, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_10x10_UNORM_BLOCK , astc, 10,10, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_12x10_UNORM_BLOCK , astc, 12,10, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_12x12_UNORM_BLOCK , astc, 12,12, x128, , , , xyzw, rgb -VK_FORMAT_ASTC_4x4_SRGB_BLOCK , astc, 4, 4, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_5x4_SRGB_BLOCK , astc, 5, 4, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_5x5_SRGB_BLOCK , astc, 5, 5, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_6x5_SRGB_BLOCK , astc, 6, 5, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_6x6_SRGB_BLOCK , astc, 6, 6, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_8x5_SRGB_BLOCK , astc, 8, 5, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_8x6_SRGB_BLOCK , astc, 8, 6, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_8x8_SRGB_BLOCK , astc, 8, 8, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_10x5_SRGB_BLOCK , astc, 10, 5, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_10x6_SRGB_BLOCK , astc, 10, 6, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_10x8_SRGB_BLOCK , astc, 10, 8, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_10x10_SRGB_BLOCK , astc, 10,10, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_12x10_SRGB_BLOCK , astc, 12,10, x128, , , , xyzw, srgb -VK_FORMAT_ASTC_12x12_SRGB_BLOCK , astc, 12,12, x128, , , , xyzw, srgb diff --git a/src/freedreno/vulkan/vk_format_table.py b/src/freedreno/vulkan/vk_format_table.py deleted file mode 100644 index db9a48ea152..00000000000 --- a/src/freedreno/vulkan/vk_format_table.py +++ /dev/null @@ -1,173 +0,0 @@ -from __future__ import print_function - -CopyRight = ''' -/************************************************************************** - * - * Copyright 2010 VMware, Inc. - * All Rights Reserved. - * - * 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, sub license, 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 NON-INFRINGEMENT. - * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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. - * - **************************************************************************/ -''' - - -import sys - -from vk_format_parse import * - -def layout_map(layout): - return 'VK_FORMAT_LAYOUT_' + str(layout).upper() - - -def colorspace_map(colorspace): - return 'VK_FORMAT_COLORSPACE_' + str(colorspace).upper() - - -colorspace_channels_map = { - 'rgb': ['r', 'g', 'b', 'a'], - 'srgb': ['sr', 'sg', 'sb', 'a'], - 'zs': ['z', 's'], - 'yuv': ['y', 'u', 'v'], -} - - -type_map = { - VOID: "VK_FORMAT_TYPE_VOID", - UNSIGNED: "VK_FORMAT_TYPE_UNSIGNED", - SIGNED: "VK_FORMAT_TYPE_SIGNED", - FIXED: "VK_FORMAT_TYPE_FIXED", - FLOAT: "VK_FORMAT_TYPE_FLOAT", -} - - -def bool_map(value): - if value: - return "true" - else: - return "false" - - -swizzle_map = { - SWIZZLE_X: "VK_SWIZZLE_X", - SWIZZLE_Y: "VK_SWIZZLE_Y", - SWIZZLE_Z: "VK_SWIZZLE_Z", - SWIZZLE_W: "VK_SWIZZLE_W", - SWIZZLE_0: "VK_SWIZZLE_0", - SWIZZLE_1: "VK_SWIZZLE_1", - SWIZZLE_NONE: "VK_SWIZZLE_NONE", -} - -def print_channels(format, func): - if format.nr_channels() <= 1: - func(format.le_channels, format.le_swizzles) - else: - print('#if UTIL_ARCH_BIG_ENDIAN') - func(format.be_channels, format.be_swizzles) - print('#else') - func(format.le_channels, format.le_swizzles) - print('#endif') - -def write_format_table(formats): - print('/* This file is autogenerated by vk_format_table.py from vk_format_layout.csv. Do not edit directly. */') - print() - # This will print the copyright message on the top of this file - print(CopyRight.strip()) - print() - print('#include "stdbool.h"') - print('#include "vk_format.h"') - print() - - def do_channel_array(channels, swizzles): - print(" {") - for i in range(4): - channel = channels[i] - if i < 3: - sep = "," - else: - sep = "" - if channel.size: - print(" {%s, %s, %s, %s, %u, %u}%s\t/* %s = %s */" % (type_map[channel.type], bool_map(channel.norm), bool_map(channel.pure), bool_map(channel.scaled), channel.size, channel.shift, sep, "xyzw"[i], channel.name)) - else: - print(" {0, 0, 0, 0, 0}%s" % (sep,)) - print(" },") - - def do_swizzle_array(channels, swizzles): - print(" {") - for i in range(4): - swizzle = swizzles[i] - if i < 3: - sep = "," - else: - sep = "" - try: - comment = colorspace_channels_map[format.colorspace][i] - except (KeyError, IndexError): - comment = 'ignored' - print(" %s%s\t/* %s */" % (swizzle_map[swizzle], sep, comment)) - print(" },") - - for format in formats: - print('static const struct vk_format_description') - print('vk_format_%s_description = {' % (format.short_name(),)) - print(" %s," % (format.name,)) - print(" \"%s\"," % (format.name,)) - print(" \"%s\"," % (format.short_name(),)) - print(" {%u, %u, %u},\t/* block */" % (format.block_width, format.block_height, format.block_size())) - print(" %s," % (layout_map(format.layout),)) - print(" %u,\t/* nr_channels */" % (format.nr_channels(),)) - print(" %s,\t/* is_array */" % (bool_map(format.is_array()),)) - print(" %s,\t/* is_bitmask */" % (bool_map(format.is_bitmask()),)) - print(" %s,\t/* is_mixed */" % (bool_map(format.is_mixed()),)) - print_channels(format, do_channel_array) - print_channels(format, do_swizzle_array) - print(" %s," % (colorspace_map(format.colorspace),)) - print("};") - print() - - print("const struct vk_format_description *") - print("vk_format_description(VkFormat format)") - print("{") - print(" if (format > VK_FORMAT_END_RANGE) {") - print(" return NULL;") - print(" }") - print() - print(" switch (format) {") - for format in formats: - print(" case %s:" % format.name) - print(" return &vk_format_%s_description;" % (format.short_name(),)) - print(" default:") - print(" return NULL;") - print(" }") - print("}") - print() - - -def main(): - - formats = [] - for arg in sys.argv[1:]: - formats.extend(parse(arg)) - write_format_table(formats) - - -if __name__ == '__main__': - main()