mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-31 22:50:08 +01:00
radv: Remove the format table.
Kill some code! Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com> Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/8797>
This commit is contained in:
Bas Nieuwenhuizen
Marge Bot
parent
d9d9acd3ea
commit
fa26c09fb0
7 changed files with 2 additions and 929 deletions
|
|
@ -77,14 +77,10 @@ LOCAL_STATIC_LIBRARIES := \
|
|||
|
||||
LOCAL_GENERATED_SOURCES += $(intermediates)/radv_entrypoints.c
|
||||
LOCAL_GENERATED_SOURCES += $(intermediates)/radv_entrypoints.h
|
||||
LOCAL_GENERATED_SOURCES += $(intermediates)/vk_format_table.c
|
||||
|
||||
RADV_ENTRYPOINTS_SCRIPT := $(MESA_TOP)/src/vulkan/util/vk_entrypoints_gen.py
|
||||
VK_FORMAT_TABLE_SCRIPT := $(MESA_TOP)/src/amd/vulkan/vk_format_table.py
|
||||
VK_FORMAT_PARSE_SCRIPT := $(MESA_TOP)/src/amd/vulkan/vk_format_parse.py
|
||||
|
||||
vulkan_api_xml = $(MESA_TOP)/src/vulkan/registry/vk.xml
|
||||
vk_format_layout_csv = $(MESA_TOP)/src/amd/vulkan/vk_format_layout.csv
|
||||
|
||||
$(intermediates)/radv_entrypoints.c: $(RADV_ENTRYPOINTS_SCRIPT) \
|
||||
$(vulkan_api_xml)
|
||||
|
|
@ -98,12 +94,6 @@ $(intermediates)/radv_entrypoints.c: $(RADV_ENTRYPOINTS_SCRIPT) \
|
|||
|
||||
$(intermediates)/radv_entrypoints.h: $(intermediates)/radv_entrypoints.c
|
||||
|
||||
$(intermediates)/vk_format_table.c: $(VK_FORMAT_TABLE_SCRIPT) \
|
||||
$(VK_FORMAT_PARSE_SCRIPT) \
|
||||
$(vk_format_layout_csv)
|
||||
@mkdir -p $(dir $@)
|
||||
$(MESA_PYTHON2) $(VK_FORMAT_TABLE_SCRIPT) $(vk_format_layout_csv) > $@
|
||||
|
||||
LOCAL_SHARED_LIBRARIES += $(RADV_SHARED_LIBRARIES)
|
||||
|
||||
LOCAL_EXPORT_C_INCLUDE_DIRS := \
|
||||
|
|
|
|||
|
|
@ -104,6 +104,5 @@ VULKAN_WSI_DISPLAY_FILES := \
|
|||
|
||||
VULKAN_GENERATED_FILES := \
|
||||
radv_entrypoints.c \
|
||||
radv_entrypoints.h \
|
||||
vk_format_table.c
|
||||
radv_entrypoints.h
|
||||
|
||||
|
|
|
|||
|
|
@ -29,15 +29,6 @@ radv_entrypoints = custom_target(
|
|||
],
|
||||
)
|
||||
|
||||
amd_vk_format_table_c = custom_target(
|
||||
'amd_vk_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,
|
||||
)
|
||||
|
||||
libradv_files = files(
|
||||
'layers/radv_sqtt_layer.c',
|
||||
'winsys/null/radv_null_bo.c',
|
||||
|
|
@ -160,7 +151,7 @@ endif
|
|||
|
||||
libvulkan_radeon = shared_library(
|
||||
'vulkan_radeon',
|
||||
[libradv_files, radv_entrypoints, amd_vk_format_table_c, sha1_h],
|
||||
[libradv_files, radv_entrypoints, sha1_h],
|
||||
include_directories : [
|
||||
inc_include, inc_src, inc_mapi, inc_mesa, inc_gallium, inc_gallium_aux, inc_amd, inc_amd_common, inc_amd_common_llvm, inc_compiler, inc_util, inc_vulkan_wsi,
|
||||
],
|
||||
|
|
|
|||
|
|
@ -32,122 +32,6 @@
|
|||
#include <util/macros.h>
|
||||
#include <vulkan/util/vk_format.h>
|
||||
|
||||
enum vk_format_layout {
|
||||
/**
|
||||
* 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,
|
||||
|
||||
/**
|
||||
* Formats that contain multiple planes.
|
||||
*/
|
||||
VK_FORMAT_LAYOUT_MULTIPLANE = 10,
|
||||
};
|
||||
|
||||
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 util_format_colorspace colorspace;
|
||||
|
||||
unsigned plane_count:2;
|
||||
unsigned width_divisor:2;
|
||||
unsigned height_divisor:2;
|
||||
VkFormat plane_formats[3];
|
||||
};
|
||||
|
||||
extern const struct vk_format_description vk_format_description_table[];
|
||||
|
||||
static inline const struct util_format_description *vk_format_description(VkFormat format)
|
||||
{
|
||||
return util_format_description(vk_format_to_pipe_format(format));
|
||||
|
|
|
|||
|
|
@ -1,202 +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 , yzwx, rgb
|
||||
VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT , plain, 1, 1, un4 , un4 , un4 , un4 , zyxw, rgb
|
||||
VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT , plain, 1, 1, un4 , un4 , un4 , un4 , xyzw, 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 , yzwx, 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 , other, 1, 1, x32 , , , , 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_G8B8G8R8_422_UNORM , subsampled, 2, 1, un8, un8, un8, un8, zyx1, rgb
|
||||
VK_FORMAT_B8G8R8G8_422_UNORM , subsampled, 2, 1, un8, un8, un8, un8, zyx1, rgb
|
||||
VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM , multiplane, 1, 1, x8, , , , xyz1, rgb, 420, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM
|
||||
VK_FORMAT_G8_B8R8_2PLANE_420_UNORM , multiplane, 1, 1, x8, , , , xyz1, rgb, 420, VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM
|
||||
VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM , multiplane, 1, 1, x8, , , , xyz1, rgb, 422, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM
|
||||
VK_FORMAT_G8_B8R8_2PLANE_422_UNORM , multiplane, 1, 1, x8, , , , xyz1, rgb, 422, VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM
|
||||
VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM , multiplane, 1, 1, x8, , , , xyz1, rgb, 444, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_UNORM
|
||||
VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, multiplane, 1, 1, x16, , , , xyz1, rgb, 420, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM
|
||||
VK_FORMAT_G16_B16R16_2PLANE_420_UNORM , multiplane, 1, 1, x16, , , , xyz1, rgb, 420, VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM
|
||||
VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, multiplane, 1, 1, x16, , , , xyz1, rgb, 422, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM
|
||||
VK_FORMAT_G16_B16R16_2PLANE_422_UNORM , multiplane, 1, 1, x16, , , , xyz1, rgb, 422, VK_FORMAT_R16_UNORM, VK_FORMAT_R16G16_UNORM
|
||||
VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, multiplane, 1, 1, x16, , , , xyz1, rgb, 444, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_UNORM
|
||||
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,
|
||||
VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
|
||||
VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
|
||||
VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
|
||||
|
|
|
@ -1,416 +0,0 @@
|
|||
|
||||
'''
|
||||
/**************************************************************************
|
||||
*
|
||||
* Copyright 2009 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.
|
||||
*
|
||||
**************************************************************************/
|
||||
'''
|
||||
|
||||
|
||||
VOID, UNSIGNED, SIGNED, FIXED, FLOAT = range(5)
|
||||
|
||||
SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W, SWIZZLE_0, SWIZZLE_1, SWIZZLE_NONE, = range(7)
|
||||
|
||||
PLAIN = 'plain'
|
||||
SCALED = 'scaled'
|
||||
|
||||
RGB = 'rgb'
|
||||
SRGB = 'srgb'
|
||||
YUV = 'yuv'
|
||||
ZS = 'zs'
|
||||
|
||||
|
||||
def is_pot(x):
|
||||
return (x & (x - 1)) == 0
|
||||
|
||||
|
||||
VERY_LARGE = 99999999999999999999999
|
||||
|
||||
|
||||
class Channel:
|
||||
'''Describe the channel of a color channel.'''
|
||||
|
||||
def __init__(self, type, norm, pure, scaled, size, name = ''):
|
||||
self.type = type
|
||||
self.norm = norm
|
||||
self.pure = pure
|
||||
self.size = size
|
||||
self.scaled = scaled
|
||||
self.sign = type in (SIGNED, FIXED, FLOAT)
|
||||
self.name = name
|
||||
|
||||
def __str__(self):
|
||||
s = str(self.type)
|
||||
if self.norm:
|
||||
s += 'n'
|
||||
if self.pure:
|
||||
s += 'p'
|
||||
if self.scaled:
|
||||
s += 's'
|
||||
s += str(self.size)
|
||||
return s
|
||||
|
||||
def __eq__(self, other):
|
||||
if other is None:
|
||||
return False
|
||||
|
||||
return self.type == other.type and self.norm == other.norm and self.pure == other.pure and self.size == other.size and self.scaled == other.scaled
|
||||
|
||||
def __ne__(self, other):
|
||||
return not self == other
|
||||
|
||||
def max(self):
|
||||
'''Maximum representable number.'''
|
||||
if self.type == FLOAT:
|
||||
return VERY_LARGE
|
||||
if self.type == FIXED:
|
||||
return (1 << (self.size/2)) - 1
|
||||
if self.norm:
|
||||
return 1
|
||||
if self.type == UNSIGNED:
|
||||
return (1 << self.size) - 1
|
||||
if self.type == SIGNED:
|
||||
return (1 << (self.size - 1)) - 1
|
||||
assert False
|
||||
|
||||
def min(self):
|
||||
'''Minimum representable number.'''
|
||||
if self.type == FLOAT:
|
||||
return -VERY_LARGE
|
||||
if self.type == FIXED:
|
||||
return -(1 << (self.size/2))
|
||||
if self.type == UNSIGNED:
|
||||
return 0
|
||||
if self.norm:
|
||||
return -1
|
||||
if self.type == SIGNED:
|
||||
return -(1 << (self.size - 1))
|
||||
assert False
|
||||
|
||||
|
||||
class Format:
|
||||
'''Describe a pixel format.'''
|
||||
|
||||
def __init__(self, name, layout, block_width, block_height, le_channels, le_swizzles, be_channels, be_swizzles, colorspace, width_divisor, height_divisor, plane_formats):
|
||||
self.name = name
|
||||
self.layout = layout
|
||||
self.block_width = block_width
|
||||
self.block_height = block_height
|
||||
self.le_channels = le_channels
|
||||
self.le_swizzles = le_swizzles
|
||||
self.be_channels = be_channels
|
||||
self.be_swizzles = be_swizzles
|
||||
self.name = name
|
||||
self.colorspace = colorspace
|
||||
self.plane_count = len(plane_formats)
|
||||
self.width_divisor = width_divisor
|
||||
self.height_divisor = height_divisor
|
||||
self.plane_formats = plane_formats
|
||||
|
||||
while len(self.plane_formats) < 3:
|
||||
self.plane_formats.append("VK_FORMAT_UNDEFINED")
|
||||
|
||||
def __str__(self):
|
||||
return self.name
|
||||
|
||||
def short_name(self):
|
||||
'''Make up a short norm for a format, suitable to be used as suffix in
|
||||
function names.'''
|
||||
|
||||
name = self.name
|
||||
if name.startswith('VK_FORMAT_'):
|
||||
name = name[len('VK_FORMAT_'):]
|
||||
name = name.lower()
|
||||
return name
|
||||
|
||||
def block_size(self):
|
||||
size = 0
|
||||
for channel in self.le_channels:
|
||||
size += channel.size
|
||||
return size
|
||||
|
||||
def nr_channels(self):
|
||||
nr_channels = 0
|
||||
for channel in self.le_channels:
|
||||
if channel.size:
|
||||
nr_channels += 1
|
||||
return nr_channels
|
||||
|
||||
def array_element(self):
|
||||
if self.layout != PLAIN:
|
||||
return None
|
||||
ref_channel = self.le_channels[0]
|
||||
if ref_channel.type == VOID:
|
||||
ref_channel = self.le_channels[1]
|
||||
for channel in self.le_channels:
|
||||
if channel.size and (channel.size != ref_channel.size or channel.size % 8):
|
||||
return None
|
||||
if channel.type != VOID:
|
||||
if channel.type != ref_channel.type:
|
||||
return None
|
||||
if channel.norm != ref_channel.norm:
|
||||
return None
|
||||
if channel.pure != ref_channel.pure:
|
||||
return None
|
||||
if channel.scaled != ref_channel.scaled:
|
||||
return None
|
||||
return ref_channel
|
||||
|
||||
def is_array(self):
|
||||
return self.array_element() != None
|
||||
|
||||
def is_mixed(self):
|
||||
if self.layout != PLAIN:
|
||||
return False
|
||||
ref_channel = self.le_channels[0]
|
||||
if ref_channel.type == VOID:
|
||||
ref_channel = self.le_channels[1]
|
||||
for channel in self.le_channels[1:]:
|
||||
if channel.type != VOID:
|
||||
if channel.type != ref_channel.type:
|
||||
return True
|
||||
if channel.norm != ref_channel.norm:
|
||||
return True
|
||||
if channel.pure != ref_channel.pure:
|
||||
return True
|
||||
if channel.scaled != ref_channel.scaled:
|
||||
return True
|
||||
return False
|
||||
|
||||
def is_pot(self):
|
||||
return is_pot(self.block_size())
|
||||
|
||||
def is_int(self):
|
||||
if self.layout != PLAIN:
|
||||
return False
|
||||
for channel in self.le_channels:
|
||||
if channel.type not in (VOID, UNSIGNED, SIGNED):
|
||||
return False
|
||||
return True
|
||||
|
||||
def is_float(self):
|
||||
if self.layout != PLAIN:
|
||||
return False
|
||||
for channel in self.le_channels:
|
||||
if channel.type not in (VOID, FLOAT):
|
||||
return False
|
||||
return True
|
||||
|
||||
def is_bitmask(self):
|
||||
if self.layout != PLAIN:
|
||||
return False
|
||||
if self.block_size() not in (8, 16, 32):
|
||||
return False
|
||||
for channel in self.le_channels:
|
||||
if channel.type not in (VOID, UNSIGNED, SIGNED):
|
||||
return False
|
||||
return True
|
||||
|
||||
def is_pure_color(self):
|
||||
if self.layout != PLAIN or self.colorspace == ZS:
|
||||
return False
|
||||
pures = [channel.pure
|
||||
for channel in self.le_channels
|
||||
if channel.type != VOID]
|
||||
for x in pures:
|
||||
assert x == pures[0]
|
||||
return pures[0]
|
||||
|
||||
def channel_type(self):
|
||||
types = [channel.type
|
||||
for channel in self.le_channels
|
||||
if channel.type != VOID]
|
||||
for x in types:
|
||||
assert x == types[0]
|
||||
return types[0]
|
||||
|
||||
def is_pure_signed(self):
|
||||
return self.is_pure_color() and self.channel_type() == SIGNED
|
||||
|
||||
def is_pure_unsigned(self):
|
||||
return self.is_pure_color() and self.channel_type() == UNSIGNED
|
||||
|
||||
def has_channel(self, id):
|
||||
return self.le_swizzles[id] != SWIZZLE_NONE
|
||||
|
||||
def has_depth(self):
|
||||
return self.colorspace == ZS and self.has_channel(0)
|
||||
|
||||
def has_stencil(self):
|
||||
return self.colorspace == ZS and self.has_channel(1)
|
||||
|
||||
def stride(self):
|
||||
return self.block_size()/8
|
||||
|
||||
|
||||
_type_parse_map = {
|
||||
'': VOID,
|
||||
'x': VOID,
|
||||
'u': UNSIGNED,
|
||||
's': SIGNED,
|
||||
'h': FIXED,
|
||||
'f': FLOAT,
|
||||
}
|
||||
|
||||
_swizzle_parse_map = {
|
||||
'x': SWIZZLE_X,
|
||||
'y': SWIZZLE_Y,
|
||||
'z': SWIZZLE_Z,
|
||||
'w': SWIZZLE_W,
|
||||
'0': SWIZZLE_0,
|
||||
'1': SWIZZLE_1,
|
||||
'_': SWIZZLE_NONE,
|
||||
}
|
||||
|
||||
def _parse_channels(fields, layout, colorspace, swizzles):
|
||||
if layout == PLAIN:
|
||||
names = ['']*4
|
||||
if colorspace in (RGB, SRGB):
|
||||
for i in range(4):
|
||||
swizzle = swizzles[i]
|
||||
if swizzle < 4:
|
||||
names[swizzle] += 'rgba'[i]
|
||||
elif colorspace == ZS:
|
||||
for i in range(4):
|
||||
swizzle = swizzles[i]
|
||||
if swizzle < 4:
|
||||
names[swizzle] += 'zs'[i]
|
||||
else:
|
||||
assert False
|
||||
for i in range(4):
|
||||
if names[i] == '':
|
||||
names[i] = 'x'
|
||||
else:
|
||||
names = ['x', 'y', 'z', 'w']
|
||||
|
||||
channels = []
|
||||
for i in range(0, 4):
|
||||
field = fields[i]
|
||||
if field:
|
||||
type = _type_parse_map[field[0]]
|
||||
if field[1] == 'n':
|
||||
norm = True
|
||||
pure = False
|
||||
scaled = False
|
||||
size = int(field[2:])
|
||||
elif field[1] == 'p':
|
||||
pure = True
|
||||
norm = False
|
||||
scaled = False
|
||||
size = int(field[2:])
|
||||
elif field[1] == 's':
|
||||
pure = False
|
||||
norm = False
|
||||
scaled = True
|
||||
size = int(field[2:])
|
||||
else:
|
||||
norm = False
|
||||
pure = False
|
||||
scaled = False
|
||||
size = int(field[1:])
|
||||
else:
|
||||
type = VOID
|
||||
norm = False
|
||||
pure = False
|
||||
scaled = False
|
||||
size = 0
|
||||
channel = Channel(type, norm, pure, scaled, size, names[i])
|
||||
channels.append(channel)
|
||||
|
||||
return channels
|
||||
|
||||
def parse_plane_divisor(format):
|
||||
if format == '444':
|
||||
return (1, 1)
|
||||
elif format == '422':
|
||||
return (2, 1)
|
||||
elif format == '420':
|
||||
return (2, 2)
|
||||
else:
|
||||
return (1, 1)
|
||||
|
||||
def parse(filename):
|
||||
'''Parse the format description in CSV format in terms of the
|
||||
Channel and Format classes above.'''
|
||||
|
||||
stream = open(filename)
|
||||
formats = []
|
||||
for line in stream:
|
||||
try:
|
||||
comment = line.index('#')
|
||||
except ValueError:
|
||||
pass
|
||||
else:
|
||||
line = line[:comment]
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
fields = [field.strip() for field in line.split(',')]
|
||||
if len (fields) < 10:
|
||||
continue
|
||||
|
||||
be_fields = fields[4:9]
|
||||
|
||||
name = fields[0]
|
||||
layout = fields[1]
|
||||
block_width, block_height = map(int, fields[2:4])
|
||||
colorspace = fields[9]
|
||||
|
||||
le_swizzles = [_swizzle_parse_map[swizzle] for swizzle in fields[8]]
|
||||
le_channels = _parse_channels(fields[4:8], layout, colorspace, le_swizzles)
|
||||
|
||||
be_swizzles = [_swizzle_parse_map[swizzle] for swizzle in be_fields[4]]
|
||||
be_channels = _parse_channels(be_fields, layout, colorspace, be_swizzles)
|
||||
|
||||
le_shift = 0
|
||||
for channel in le_channels:
|
||||
channel.shift = le_shift
|
||||
le_shift += channel.size
|
||||
|
||||
be_shift = 0
|
||||
for channel in be_channels[3::-1]:
|
||||
channel.shift = be_shift
|
||||
be_shift += channel.size
|
||||
|
||||
assert le_shift == be_shift
|
||||
for i in range(4):
|
||||
assert (le_swizzles[i] != SWIZZLE_NONE) == (be_swizzles[i] != SWIZZLE_NONE)
|
||||
|
||||
width_divisor = 1
|
||||
height_divisor = 1
|
||||
plane_formats = [name]
|
||||
if layout == "multiplane":
|
||||
plane_formats = []
|
||||
(width_divisor, height_divisor) = parse_plane_divisor(fields[10])
|
||||
|
||||
for i in range(11, len(fields)):
|
||||
plane_formats.append(fields[i])
|
||||
assert (len(plane_formats) > 1)
|
||||
|
||||
format = Format(name, layout, block_width, block_height, le_channels, le_swizzles, be_channels, be_swizzles, colorspace, width_divisor, height_divisor, plane_formats)
|
||||
formats.append(format)
|
||||
return formats
|
||||
|
||||
|
|
@ -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: "PIPE_SWIZZLE_X",
|
||||
SWIZZLE_Y: "PIPE_SWIZZLE_Y",
|
||||
SWIZZLE_Z: "PIPE_SWIZZLE_Z",
|
||||
SWIZZLE_W: "PIPE_SWIZZLE_W",
|
||||
SWIZZLE_0: "PIPE_SWIZZLE_0",
|
||||
SWIZZLE_1: "PIPE_SWIZZLE_1",
|
||||
SWIZZLE_NONE: "PIPE_SWIZZLE_NONE",
|
||||
}
|
||||
|
||||
def print_channels(format, func):
|
||||
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(" %u,\t/* plane_count */" % (format.plane_count))
|
||||
print(" %u,\t/* width_divisor */" % (format.width_divisor))
|
||||
print(" %u,\t/* height_divisor */" % (format.height_divisor))
|
||||
print(" {%s, %s, %s}," % (format.plane_formats[0], format.plane_formats[1], format.plane_formats[2]))
|
||||
print("};")
|
||||
print()
|
||||
|
||||
print("static const struct vk_format_description *")
|
||||
print("vk_format_description_legacy(VkFormat format)")
|
||||
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()
|
||||
Loading…
Add table
Reference in a new issue