initial commit, 4.5 stable
Some checks failed
🔗 GHA / 📊 Static checks (push) Has been cancelled
🔗 GHA / 🤖 Android (push) Has been cancelled
🔗 GHA / 🍏 iOS (push) Has been cancelled
🔗 GHA / 🐧 Linux (push) Has been cancelled
🔗 GHA / 🍎 macOS (push) Has been cancelled
🔗 GHA / 🏁 Windows (push) Has been cancelled
🔗 GHA / 🌐 Web (push) Has been cancelled
Some checks failed
🔗 GHA / 📊 Static checks (push) Has been cancelled
🔗 GHA / 🤖 Android (push) Has been cancelled
🔗 GHA / 🍏 iOS (push) Has been cancelled
🔗 GHA / 🐧 Linux (push) Has been cancelled
🔗 GHA / 🍎 macOS (push) Has been cancelled
🔗 GHA / 🏁 Windows (push) Has been cancelled
🔗 GHA / 🌐 Web (push) Has been cancelled
This commit is contained in:
654
thirdparty/libktx/external/dfdutils/KHR/khr_df.h
vendored
Normal file
654
thirdparty/libktx/external/dfdutils/KHR/khr_df.h
vendored
Normal file
@@ -0,0 +1,654 @@
|
||||
/* The Khronos Data Format Specification (version 1.4.0) */
|
||||
/*
|
||||
** Copyright 2015-2025 The Khronos Group Inc.
|
||||
** SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/* This header defines a structure that can describe the layout of image
|
||||
formats in memory. This means that the data format is transparent to
|
||||
the application, and the expectation is that this should be used when
|
||||
the layout is defined external to the API. Many Khronos APIs deliberately
|
||||
keep the internal layout of images opaque, to allow proprietary layouts
|
||||
and optimisations. This structure is not appropriate for describing
|
||||
opaque layouts. */
|
||||
|
||||
/* We stick to standard C89 constructs for simplicity and portability. */
|
||||
|
||||
#ifndef _KHR_DATA_FORMAT_H_
|
||||
#define _KHR_DATA_FORMAT_H_
|
||||
|
||||
/* Accessors */
|
||||
typedef enum _khr_word_e {
|
||||
KHR_DF_WORD_VENDORID = 0U,
|
||||
KHR_DF_WORD_DESCRIPTORTYPE = 0U,
|
||||
KHR_DF_WORD_VERSIONNUMBER = 1U,
|
||||
KHR_DF_WORD_DESCRIPTORBLOCKSIZE = 1U,
|
||||
KHR_DF_WORD_MODEL = 2U,
|
||||
KHR_DF_WORD_PRIMARIES = 2U,
|
||||
KHR_DF_WORD_TRANSFER = 2U,
|
||||
KHR_DF_WORD_FLAGS = 2U,
|
||||
KHR_DF_WORD_TEXELBLOCKDIMENSION0 = 3U,
|
||||
KHR_DF_WORD_TEXELBLOCKDIMENSION1 = 3U,
|
||||
KHR_DF_WORD_TEXELBLOCKDIMENSION2 = 3U,
|
||||
KHR_DF_WORD_TEXELBLOCKDIMENSION3 = 3U,
|
||||
KHR_DF_WORD_BYTESPLANE0 = 4U,
|
||||
KHR_DF_WORD_BYTESPLANE1 = 4U,
|
||||
KHR_DF_WORD_BYTESPLANE2 = 4U,
|
||||
KHR_DF_WORD_BYTESPLANE3 = 4U,
|
||||
KHR_DF_WORD_BYTESPLANE4 = 5U,
|
||||
KHR_DF_WORD_BYTESPLANE5 = 5U,
|
||||
KHR_DF_WORD_BYTESPLANE6 = 5U,
|
||||
KHR_DF_WORD_BYTESPLANE7 = 5U,
|
||||
KHR_DF_WORD_SAMPLESTART = 6U,
|
||||
KHR_DF_WORD_SAMPLEWORDS = 4U
|
||||
} khr_df_word_e;
|
||||
|
||||
typedef enum _khr_df_shift_e {
|
||||
KHR_DF_SHIFT_VENDORID = 0U,
|
||||
KHR_DF_SHIFT_DESCRIPTORTYPE = 17U,
|
||||
KHR_DF_SHIFT_VERSIONNUMBER = 0U,
|
||||
KHR_DF_SHIFT_DESCRIPTORBLOCKSIZE = 16U,
|
||||
KHR_DF_SHIFT_MODEL = 0U,
|
||||
KHR_DF_SHIFT_PRIMARIES = 8U,
|
||||
KHR_DF_SHIFT_TRANSFER = 16U,
|
||||
KHR_DF_SHIFT_FLAGS = 24U,
|
||||
KHR_DF_SHIFT_TEXELBLOCKDIMENSION0 = 0U,
|
||||
KHR_DF_SHIFT_TEXELBLOCKDIMENSION1 = 8U,
|
||||
KHR_DF_SHIFT_TEXELBLOCKDIMENSION2 = 16U,
|
||||
KHR_DF_SHIFT_TEXELBLOCKDIMENSION3 = 24U,
|
||||
KHR_DF_SHIFT_BYTESPLANE0 = 0U,
|
||||
KHR_DF_SHIFT_BYTESPLANE1 = 8U,
|
||||
KHR_DF_SHIFT_BYTESPLANE2 = 16U,
|
||||
KHR_DF_SHIFT_BYTESPLANE3 = 24U,
|
||||
KHR_DF_SHIFT_BYTESPLANE4 = 0U,
|
||||
KHR_DF_SHIFT_BYTESPLANE5 = 8U,
|
||||
KHR_DF_SHIFT_BYTESPLANE6 = 16U,
|
||||
KHR_DF_SHIFT_BYTESPLANE7 = 24U
|
||||
} khr_df_shift_e;
|
||||
|
||||
typedef enum _khr_df_mask_e {
|
||||
KHR_DF_MASK_VENDORID = 0x1FFFFU,
|
||||
KHR_DF_MASK_DESCRIPTORTYPE = 0x7FFFU,
|
||||
KHR_DF_MASK_VERSIONNUMBER = 0xFFFFU,
|
||||
KHR_DF_MASK_DESCRIPTORBLOCKSIZE = 0xFFFFU,
|
||||
KHR_DF_MASK_MODEL = 0xFFU,
|
||||
KHR_DF_MASK_PRIMARIES = 0xFFU,
|
||||
KHR_DF_MASK_TRANSFER = 0xFFU,
|
||||
KHR_DF_MASK_FLAGS = 0xFFU,
|
||||
KHR_DF_MASK_TEXELBLOCKDIMENSION0 = 0xFFU,
|
||||
KHR_DF_MASK_TEXELBLOCKDIMENSION1 = 0xFFU,
|
||||
KHR_DF_MASK_TEXELBLOCKDIMENSION2 = 0xFFU,
|
||||
KHR_DF_MASK_TEXELBLOCKDIMENSION3 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE0 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE1 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE2 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE3 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE4 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE5 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE6 = 0xFFU,
|
||||
KHR_DF_MASK_BYTESPLANE7 = 0xFFU
|
||||
} khr_df_mask_e;
|
||||
|
||||
/* Helper macro:
|
||||
Extract field X from basic descriptor block BDB */
|
||||
#define KHR_DFDVAL(BDB, X) \
|
||||
(((BDB)[KHR_DF_WORD_ ## X] >> (KHR_DF_SHIFT_ ## X)) \
|
||||
& (KHR_DF_MASK_ ## X))
|
||||
|
||||
/* Helper macro:
|
||||
Set field X of basic descriptor block BDB */
|
||||
#define KHR_DFDSETVAL(BDB, X, val) \
|
||||
((BDB)[KHR_DF_WORD_ ## X] = \
|
||||
((BDB)[KHR_DF_WORD_ ## X] & \
|
||||
~((KHR_DF_MASK_ ## X) << (KHR_DF_SHIFT_ ## X))) | \
|
||||
(((uint32_t)(val) & (KHR_DF_MASK_ ## X)) << (KHR_DF_SHIFT_ ## X)))
|
||||
|
||||
/* Offsets relative to the start of a sample */
|
||||
typedef enum _khr_df_sampleword_e {
|
||||
KHR_DF_SAMPLEWORD_BITOFFSET = 0U,
|
||||
KHR_DF_SAMPLEWORD_BITLENGTH = 0U,
|
||||
KHR_DF_SAMPLEWORD_CHANNELID = 0U,
|
||||
KHR_DF_SAMPLEWORD_QUALIFIERS = 0U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEPOSITION0 = 1U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEPOSITION1 = 1U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEPOSITION2 = 1U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEPOSITION3 = 1U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEPOSITION_ALL = 1U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLELOWER = 2U,
|
||||
KHR_DF_SAMPLEWORD_SAMPLEUPPER = 3U
|
||||
} khr_df_sampleword_e;
|
||||
|
||||
typedef enum _khr_df_sampleshift_e {
|
||||
KHR_DF_SAMPLESHIFT_BITOFFSET = 0U,
|
||||
KHR_DF_SAMPLESHIFT_BITLENGTH = 16U,
|
||||
KHR_DF_SAMPLESHIFT_CHANNELID = 24U,
|
||||
/* N.B. Qualifiers are defined as an offset into a byte */
|
||||
KHR_DF_SAMPLESHIFT_QUALIFIERS = 24U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEPOSITION0 = 0U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEPOSITION1 = 8U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEPOSITION2 = 16U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEPOSITION3 = 24U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEPOSITION_ALL = 0U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLELOWER = 0U,
|
||||
KHR_DF_SAMPLESHIFT_SAMPLEUPPER = 0U
|
||||
} khr_df_sampleshift_e;
|
||||
|
||||
typedef enum _khr_df_samplemask_e {
|
||||
KHR_DF_SAMPLEMASK_BITOFFSET = 0xFFFFU,
|
||||
KHR_DF_SAMPLEMASK_BITLENGTH = 0xFFU,
|
||||
KHR_DF_SAMPLEMASK_CHANNELID = 0xFU,
|
||||
/* N.B. Qualifiers are defined as an offset into a byte */
|
||||
KHR_DF_SAMPLEMASK_QUALIFIERS = 0xF0U,
|
||||
KHR_DF_SAMPLEMASK_SAMPLEPOSITION0 = 0xFFU,
|
||||
KHR_DF_SAMPLEMASK_SAMPLEPOSITION1 = 0xFFU,
|
||||
KHR_DF_SAMPLEMASK_SAMPLEPOSITION2 = 0xFFU,
|
||||
KHR_DF_SAMPLEMASK_SAMPLEPOSITION3 = 0xFFU,
|
||||
/* ISO C restricts enum values to range of int hence the
|
||||
cast. We do it verbosely instead of using -1 to ensure
|
||||
it is a 32-bit value even if int is 64 bits. */
|
||||
KHR_DF_SAMPLEMASK_SAMPLEPOSITION_ALL = (int) 0xFFFFFFFFU,
|
||||
KHR_DF_SAMPLEMASK_SAMPLELOWER = (int) 0xFFFFFFFFU,
|
||||
KHR_DF_SAMPLEMASK_SAMPLEUPPER = (int) 0xFFFFFFFFU
|
||||
} khr_df_samplemask_e;
|
||||
|
||||
/* Helper macro:
|
||||
Extract field X of sample S from basic descriptor block BDB */
|
||||
#define KHR_DFDSVAL(BDB, S, X) \
|
||||
(((BDB)[KHR_DF_WORD_SAMPLESTART + \
|
||||
((S) * KHR_DF_WORD_SAMPLEWORDS) + \
|
||||
KHR_DF_SAMPLEWORD_ ## X] >> (KHR_DF_SAMPLESHIFT_ ## X)) \
|
||||
& (KHR_DF_SAMPLEMASK_ ## X))
|
||||
|
||||
/* Helper macro:
|
||||
Set field X of sample S of basic descriptor block BDB */
|
||||
#define KHR_DFDSETSVAL(BDB, S, X, val) \
|
||||
((BDB)[KHR_DF_WORD_SAMPLESTART + \
|
||||
((S) * KHR_DF_WORD_SAMPLEWORDS) + \
|
||||
KHR_DF_SAMPLEWORD_ ## X] = \
|
||||
((BDB)[KHR_DF_WORD_SAMPLESTART + \
|
||||
((S) * KHR_DF_WORD_SAMPLEWORDS) + \
|
||||
KHR_DF_SAMPLEWORD_ ## X] & \
|
||||
~((uint32_t)(KHR_DF_SAMPLEMASK_ ## X) << (KHR_DF_SAMPLESHIFT_ ## X))) | \
|
||||
(((uint32_t)(val) & (uint32_t)(KHR_DF_SAMPLEMASK_ ## X)) << (KHR_DF_SAMPLESHIFT_ ## X)))
|
||||
|
||||
/* Helper macro:
|
||||
Number of samples in basic descriptor block BDB */
|
||||
#define KHR_DFDSAMPLECOUNT(BDB) \
|
||||
(((KHR_DFDVAL(BDB, DESCRIPTORBLOCKSIZE) >> 2) - \
|
||||
KHR_DF_WORD_SAMPLESTART) \
|
||||
/ KHR_DF_WORD_SAMPLEWORDS)
|
||||
|
||||
/* Helper macro:
|
||||
Size in words of basic descriptor block for S samples */
|
||||
#define KHR_DFDSIZEWORDS(S) \
|
||||
(KHR_DF_WORD_SAMPLESTART + \
|
||||
(S) * KHR_DF_WORD_SAMPLEWORDS)
|
||||
|
||||
/* Vendor ids */
|
||||
typedef enum _khr_df_vendorid_e {
|
||||
/* Standard Khronos descriptor */
|
||||
KHR_DF_VENDORID_KHRONOS = 0U,
|
||||
KHR_DF_VENDORID_MAX = 0x1FFFFU
|
||||
} khr_df_vendorid_e;
|
||||
|
||||
/* Descriptor types */
|
||||
typedef enum _khr_df_khr_descriptortype_e {
|
||||
/* Default Khronos basic descriptor block */
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0U,
|
||||
/* Extension descriptor block for additional planes */
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES = 0x6001U,
|
||||
/* Extension descriptor block for additional dimensions */
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_ADDITIONAL_DIMENSIONS = 0x6002U,
|
||||
/* Bit indicates modifying requires understanding this extension */
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_WRITE_BIT = 0x2000U,
|
||||
/* Bit indicates processing requires understanding this extension */
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_NEEDED_FOR_DECODE_BIT = 0x4000U,
|
||||
KHR_DF_KHR_DESCRIPTORTYPE_MAX = 0x7FFFU
|
||||
} khr_df_khr_descriptortype_e;
|
||||
|
||||
/* Descriptor block version */
|
||||
typedef enum _khr_df_versionnumber_e {
|
||||
/* Standard Khronos descriptor */
|
||||
KHR_DF_VERSIONNUMBER_1_0 = 0U, /* Version 1.0 of the specification */
|
||||
KHR_DF_VERSIONNUMBER_1_1 = 0U, /* Version 1.1 did not bump the version number */
|
||||
KHR_DF_VERSIONNUMBER_1_2 = 1U, /* Version 1.2 increased the version number */
|
||||
KHR_DF_VERSIONNUMBER_1_3 = 2U, /* Version 1.3 increased the version number */
|
||||
KHR_DF_VERSIONNUMBER_1_4 = 2U, /* Version 1.4.0 did not bump the block version number */
|
||||
KHR_DF_VERSIONNUMBER_LATEST = KHR_DF_VERSIONNUMBER_1_4,
|
||||
KHR_DF_VERSIONNUMBER_MAX = 0xFFFFU
|
||||
} khr_df_versionnumber_e;
|
||||
|
||||
/* Model in which the color coordinate space is defined.
|
||||
There is no requirement that a color format use all the
|
||||
channel types that are defined in the color model. */
|
||||
typedef enum _khr_df_model_e {
|
||||
/* No interpretation of color channels defined */
|
||||
KHR_DF_MODEL_UNSPECIFIED = 0U,
|
||||
/* Color primaries (red, green, blue) + alpha, depth and stencil */
|
||||
KHR_DF_MODEL_RGBSDA = 1U,
|
||||
/* Color differences (Y', Cb, Cr) + alpha, depth and stencil */
|
||||
KHR_DF_MODEL_YUVSDA = 2U,
|
||||
/* Color differences (Y', I, Q) + alpha, depth and stencil */
|
||||
KHR_DF_MODEL_YIQSDA = 3U,
|
||||
/* Perceptual color (CIE L*a*b*) + alpha, depth and stencil */
|
||||
KHR_DF_MODEL_LABSDA = 4U,
|
||||
/* Subtractive colors (cyan, magenta, yellow, black) + alpha */
|
||||
KHR_DF_MODEL_CMYKA = 5U,
|
||||
/* Non-color coordinate data (X, Y, Z, W) */
|
||||
KHR_DF_MODEL_XYZW = 6U,
|
||||
/* Hue, saturation, value, hue angle on color circle, plus alpha */
|
||||
KHR_DF_MODEL_HSVA_ANG = 7U,
|
||||
/* Hue, saturation, lightness, hue angle on color circle, plus alpha */
|
||||
KHR_DF_MODEL_HSLA_ANG = 8U,
|
||||
/* Hue, saturation, value, hue on color hexagon, plus alpha */
|
||||
KHR_DF_MODEL_HSVA_HEX = 9U,
|
||||
/* Hue, saturation, lightness, hue on color hexagon, plus alpha */
|
||||
KHR_DF_MODEL_HSLA_HEX = 10U,
|
||||
/* Lightweight approximate color difference (luma, orange, green) */
|
||||
KHR_DF_MODEL_YCGCOA = 11U,
|
||||
/* ITU BT.2020 constant luminance YcCbcCrc */
|
||||
KHR_DF_MODEL_YCCBCCRC = 12U,
|
||||
/* ITU BT.2100 constant intensity ICtCp */
|
||||
KHR_DF_MODEL_ICTCP = 13U,
|
||||
/* CIE 1931 XYZ color coordinates (X, Y, Z) */
|
||||
KHR_DF_MODEL_CIEXYZ = 14U,
|
||||
/* CIE 1931 xyY color coordinates (X, Y, Y) */
|
||||
KHR_DF_MODEL_CIEXYY = 15U,
|
||||
|
||||
/* Compressed formats start at 128. */
|
||||
/* These compressed formats should generally have a single sample,
|
||||
sited at the 0,0 position of the texel block. Where multiple
|
||||
channels are used to distinguish formats, these should be cosited. */
|
||||
/* Direct3D (and S3) compressed formats */
|
||||
/* Note that premultiplied status is recorded separately */
|
||||
/* DXT1 "channels" are RGB (0), Alpha (1) */
|
||||
/* DXT1/BC1 with one channel is opaque */
|
||||
/* DXT1/BC1 with a cosited alpha sample is transparent */
|
||||
KHR_DF_MODEL_DXT1A = 128U,
|
||||
KHR_DF_MODEL_BC1A = 128U,
|
||||
/* DXT2/DXT3/BC2, with explicit 4-bit alpha */
|
||||
KHR_DF_MODEL_DXT2 = 129U,
|
||||
KHR_DF_MODEL_DXT3 = 129U,
|
||||
KHR_DF_MODEL_BC2 = 129U,
|
||||
/* DXT4/DXT5/BC3, with interpolated alpha */
|
||||
KHR_DF_MODEL_DXT4 = 130U,
|
||||
KHR_DF_MODEL_DXT5 = 130U,
|
||||
KHR_DF_MODEL_BC3 = 130U,
|
||||
/* ATI1n/DXT5A/BC4 - single channel interpolated 8-bit data */
|
||||
/* (The UNORM/SNORM variation is recorded in the channel data) */
|
||||
KHR_DF_MODEL_ATI1N = 131U,
|
||||
KHR_DF_MODEL_DXT5A = 131U,
|
||||
KHR_DF_MODEL_BC4 = 131U,
|
||||
/* ATI2n_XY/DXN/BC5 - two channel interpolated 8-bit data */
|
||||
/* (The UNORM/SNORM variation is recorded in the channel data) */
|
||||
KHR_DF_MODEL_ATI2N_XY = 132U,
|
||||
KHR_DF_MODEL_DXN = 132U,
|
||||
KHR_DF_MODEL_BC5 = 132U,
|
||||
/* BC6H - DX11 format for 16-bit float channels */
|
||||
KHR_DF_MODEL_BC6H = 133U,
|
||||
/* BC7 - DX11 format */
|
||||
KHR_DF_MODEL_BC7 = 134U,
|
||||
/* Gap left for future desktop expansion */
|
||||
|
||||
/* Mobile compressed formats follow */
|
||||
/* A format of ETC1 indicates that the format shall be decodable
|
||||
by an ETC1-compliant decoder and not rely on ETC2 features */
|
||||
KHR_DF_MODEL_ETC1 = 160U,
|
||||
/* A format of ETC2 is permitted to use ETC2 encodings on top of
|
||||
the baseline ETC1 specification */
|
||||
/* The ETC2 format has channels "red", "green", "RGB" and "alpha",
|
||||
which should be cosited samples */
|
||||
/* Punch-through alpha can be distinguished from full alpha by
|
||||
the plane size in bytes required for the texel block */
|
||||
KHR_DF_MODEL_ETC2 = 161U,
|
||||
/* Adaptive Scalable Texture Compression */
|
||||
/* ASTC HDR vs LDR is determined by the float flag in the channel */
|
||||
/* ASTC block size can be distinguished by texel block size */
|
||||
KHR_DF_MODEL_ASTC = 162U,
|
||||
/* ETC1S is a simplified subset of ETC1 */
|
||||
KHR_DF_MODEL_ETC1S = 163U,
|
||||
/* PowerVR Texture Compression */
|
||||
KHR_DF_MODEL_PVRTC = 164U,
|
||||
KHR_DF_MODEL_PVRTC2 = 165U,
|
||||
KHR_DF_MODEL_UASTC = 166U,
|
||||
/* Proprietary formats (ATITC, etc.) should follow */
|
||||
KHR_DF_MODEL_MAX = 0xFFU
|
||||
} khr_df_model_e;
|
||||
|
||||
/* Definition of channel names for each color model */
|
||||
typedef enum _khr_df_model_channels_e {
|
||||
/* Unspecified format with nominal channel numbering */
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_0 = 0U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_1 = 1U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_2 = 2U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_3 = 3U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_4 = 4U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_5 = 5U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_6 = 6U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_7 = 7U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_8 = 8U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_9 = 9U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_10 = 10U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_11 = 11U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_12 = 12U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_13 = 13U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_14 = 14U,
|
||||
KHR_DF_CHANNEL_UNSPECIFIED_15 = 15U,
|
||||
/* MODEL_RGBSDA - red, green, blue, stencil, depth, alpha */
|
||||
KHR_DF_CHANNEL_RGBSDA_RED = 0U,
|
||||
KHR_DF_CHANNEL_RGBSDA_R = 0U,
|
||||
KHR_DF_CHANNEL_RGBSDA_GREEN = 1U,
|
||||
KHR_DF_CHANNEL_RGBSDA_G = 1U,
|
||||
KHR_DF_CHANNEL_RGBSDA_BLUE = 2U,
|
||||
KHR_DF_CHANNEL_RGBSDA_B = 2U,
|
||||
KHR_DF_CHANNEL_RGBSDA_STENCIL = 13U,
|
||||
KHR_DF_CHANNEL_RGBSDA_S = 13U,
|
||||
KHR_DF_CHANNEL_RGBSDA_DEPTH = 14U,
|
||||
KHR_DF_CHANNEL_RGBSDA_D = 14U,
|
||||
KHR_DF_CHANNEL_RGBSDA_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_RGBSDA_A = 15U,
|
||||
/* MODEL_YUVSDA - luma, Cb, Cr, stencil, depth, alpha */
|
||||
KHR_DF_CHANNEL_YUVSDA_Y = 0U,
|
||||
KHR_DF_CHANNEL_YUVSDA_CB = 1U,
|
||||
KHR_DF_CHANNEL_YUVSDA_U = 1U,
|
||||
KHR_DF_CHANNEL_YUVSDA_CR = 2U,
|
||||
KHR_DF_CHANNEL_YUVSDA_V = 2U,
|
||||
KHR_DF_CHANNEL_YUVSDA_STENCIL = 13U,
|
||||
KHR_DF_CHANNEL_YUVSDA_S = 13U,
|
||||
KHR_DF_CHANNEL_YUVSDA_DEPTH = 14U,
|
||||
KHR_DF_CHANNEL_YUVSDA_D = 14U,
|
||||
KHR_DF_CHANNEL_YUVSDA_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_YUVSDA_A = 15U,
|
||||
/* MODEL_YIQSDA - luma, in-phase, quadrature, stencil, depth, alpha */
|
||||
KHR_DF_CHANNEL_YIQSDA_Y = 0U,
|
||||
KHR_DF_CHANNEL_YIQSDA_I = 1U,
|
||||
KHR_DF_CHANNEL_YIQSDA_Q = 2U,
|
||||
KHR_DF_CHANNEL_YIQSDA_STENCIL = 13U,
|
||||
KHR_DF_CHANNEL_YIQSDA_S = 13U,
|
||||
KHR_DF_CHANNEL_YIQSDA_DEPTH = 14U,
|
||||
KHR_DF_CHANNEL_YIQSDA_D = 14U,
|
||||
KHR_DF_CHANNEL_YIQSDA_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_YIQSDA_A = 15U,
|
||||
/* MODEL_LABSDA - CIELAB/L*a*b* luma, red-green, blue-yellow, stencil, depth, alpha */
|
||||
KHR_DF_CHANNEL_LABSDA_L = 0U,
|
||||
KHR_DF_CHANNEL_LABSDA_A = 1U,
|
||||
KHR_DF_CHANNEL_LABSDA_B = 2U,
|
||||
KHR_DF_CHANNEL_LABSDA_STENCIL = 13U,
|
||||
KHR_DF_CHANNEL_LABSDA_S = 13U,
|
||||
KHR_DF_CHANNEL_LABSDA_DEPTH = 14U,
|
||||
KHR_DF_CHANNEL_LABSDA_D = 14U,
|
||||
KHR_DF_CHANNEL_LABSDA_ALPHA = 15U,
|
||||
/* NOTE: KHR_DF_CHANNEL_LABSDA_A is not a synonym for alpha! */
|
||||
/* MODEL_CMYKA - cyan, magenta, yellow, key/blacK, alpha */
|
||||
KHR_DF_CHANNEL_CMYKSDA_CYAN = 0U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_C = 0U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_MAGENTA = 1U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_M = 1U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_YELLOW = 2U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_Y = 2U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_KEY = 3U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_BLACK = 3U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_K = 3U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_CMYKSDA_A = 15U,
|
||||
/* MODEL_XYZW - coordinates x, y, z, w */
|
||||
KHR_DF_CHANNEL_XYZW_X = 0U,
|
||||
KHR_DF_CHANNEL_XYZW_Y = 1U,
|
||||
KHR_DF_CHANNEL_XYZW_Z = 2U,
|
||||
KHR_DF_CHANNEL_XYZW_W = 3U,
|
||||
/* MODEL_HSVA_ANG - value (luma), saturation, hue, alpha, angular projection, conical space */
|
||||
KHR_DF_CHANNEL_HSVA_ANG_VALUE = 0U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_V = 0U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_SATURATION = 1U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_S = 1U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_HUE = 2U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_H = 2U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_HSVA_ANG_A = 15U,
|
||||
/* MODEL_HSLA_ANG - lightness (luma), saturation, hue, alpha, angular projection, double conical space */
|
||||
KHR_DF_CHANNEL_HSLA_ANG_LIGHTNESS = 0U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_L = 0U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_SATURATION = 1U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_S = 1U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_HUE = 2U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_H = 2U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_HSLA_ANG_A = 15U,
|
||||
/* MODEL_HSVA_HEX - value (luma), saturation, hue, alpha, hexagonal projection, conical space */
|
||||
KHR_DF_CHANNEL_HSVA_HEX_VALUE = 0U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_V = 0U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_SATURATION = 1U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_S = 1U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_HUE = 2U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_H = 2U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_HSVA_HEX_A = 15U,
|
||||
/* MODEL_HSLA_HEX - lightness (luma), saturation, hue, alpha, hexagonal projection, double conical space */
|
||||
KHR_DF_CHANNEL_HSLA_HEX_LIGHTNESS = 0U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_L = 0U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_SATURATION = 1U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_S = 1U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_HUE = 2U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_H = 2U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_HSLA_HEX_A = 15U,
|
||||
/* MODEL_YCGCOA - luma, green delta, orange delta, alpha */
|
||||
KHR_DF_CHANNEL_YCGCOA_Y = 0U,
|
||||
KHR_DF_CHANNEL_YCGCOA_CG = 1U,
|
||||
KHR_DF_CHANNEL_YCGCOA_CO = 2U,
|
||||
KHR_DF_CHANNEL_YCGCOA_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_YCGCOA_A = 15U,
|
||||
/* MODEL_CIEXYZ - CIE 1931 X, Y, Z */
|
||||
KHR_DF_CHANNEL_CIEXYZ_X = 0U,
|
||||
KHR_DF_CHANNEL_CIEXYZ_Y = 1U,
|
||||
KHR_DF_CHANNEL_CIEXYZ_Z = 2U,
|
||||
/* MODEL_CIEXYY - CIE 1931 x, y, Y */
|
||||
KHR_DF_CHANNEL_CIEXYY_X = 0U,
|
||||
KHR_DF_CHANNEL_CIEXYY_YCHROMA = 1U,
|
||||
KHR_DF_CHANNEL_CIEXYY_YLUMA = 2U,
|
||||
|
||||
/* Compressed formats */
|
||||
/* MODEL_DXT1A/MODEL_BC1A */
|
||||
KHR_DF_CHANNEL_DXT1A_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_BC1A_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_DXT1A_ALPHAPRESENT = 1U,
|
||||
KHR_DF_CHANNEL_DXT1A_ALPHA = 1U,
|
||||
KHR_DF_CHANNEL_BC1A_ALPHAPRESENT = 1U,
|
||||
KHR_DF_CHANNEL_BC1A_ALPHA = 1U,
|
||||
/* MODEL_DXT2/3/MODEL_BC2 */
|
||||
KHR_DF_CHANNEL_DXT2_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_DXT3_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_BC2_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_DXT2_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_DXT3_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_BC2_ALPHA = 15U,
|
||||
/* MODEL_DXT4/5/MODEL_BC3 */
|
||||
KHR_DF_CHANNEL_DXT4_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_DXT5_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_BC3_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_DXT4_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_DXT5_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_BC3_ALPHA = 15U,
|
||||
/* MODEL_BC4 */
|
||||
KHR_DF_CHANNEL_BC4_DATA = 0U,
|
||||
/* MODEL_BC5 */
|
||||
KHR_DF_CHANNEL_BC5_RED = 0U,
|
||||
KHR_DF_CHANNEL_BC5_R = 0U,
|
||||
KHR_DF_CHANNEL_BC5_GREEN = 1U,
|
||||
KHR_DF_CHANNEL_BC5_G = 1U,
|
||||
/* MODEL_BC6H */
|
||||
KHR_DF_CHANNEL_BC6H_COLOR = 0U,
|
||||
KHR_DF_CHANNEL_BC6H_DATA = 0U,
|
||||
/* MODEL_BC7 */
|
||||
KHR_DF_CHANNEL_BC7_DATA = 0U,
|
||||
KHR_DF_CHANNEL_BC7_COLOR = 0U,
|
||||
/* MODEL_ETC1 */
|
||||
KHR_DF_CHANNEL_ETC1_DATA = 0U,
|
||||
KHR_DF_CHANNEL_ETC1_COLOR = 0U,
|
||||
/* MODEL_ETC2 */
|
||||
KHR_DF_CHANNEL_ETC2_RED = 0U,
|
||||
KHR_DF_CHANNEL_ETC2_R = 0U,
|
||||
KHR_DF_CHANNEL_ETC2_GREEN = 1U,
|
||||
KHR_DF_CHANNEL_ETC2_G = 1U,
|
||||
KHR_DF_CHANNEL_ETC2_COLOR = 2U,
|
||||
KHR_DF_CHANNEL_ETC2_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_ETC2_A = 15U,
|
||||
/* MODEL_ASTC */
|
||||
KHR_DF_CHANNEL_ASTC_DATA = 0U,
|
||||
/* MODEL_ETC1S */
|
||||
KHR_DF_CHANNEL_ETC1S_RGB = 0U,
|
||||
KHR_DF_CHANNEL_ETC1S_RRR = 3U,
|
||||
KHR_DF_CHANNEL_ETC1S_GGG = 4U,
|
||||
KHR_DF_CHANNEL_ETC1S_AAA = 15U,
|
||||
/* MODEL_PVRTC */
|
||||
KHR_DF_CHANNEL_PVRTC_DATA = 0U,
|
||||
KHR_DF_CHANNEL_PVRTC_COLOR = 0U,
|
||||
/* MODEL_PVRTC2 */
|
||||
KHR_DF_CHANNEL_PVRTC2_DATA = 0U,
|
||||
KHR_DF_CHANNEL_PVRTC2_COLOR = 0U,
|
||||
/* MODEL UASTC */
|
||||
KHR_DF_CHANNEL_UASTC_RGB = 0U,
|
||||
KHR_DF_CHANNEL_UASTC_RGBA = 3U,
|
||||
KHR_DF_CHANNEL_UASTC_RRR = 4U,
|
||||
KHR_DF_CHANNEL_UASTC_RRRG = 5U,
|
||||
KHR_DF_CHANNEL_UASTC_RG = 6U,
|
||||
|
||||
/* Common channel names shared by multiple formats */
|
||||
KHR_DF_CHANNEL_COMMON_LUMA = 0U,
|
||||
KHR_DF_CHANNEL_COMMON_L = 0U,
|
||||
KHR_DF_CHANNEL_COMMON_STENCIL = 13U,
|
||||
KHR_DF_CHANNEL_COMMON_S = 13U,
|
||||
KHR_DF_CHANNEL_COMMON_DEPTH = 14U,
|
||||
KHR_DF_CHANNEL_COMMON_D = 14U,
|
||||
KHR_DF_CHANNEL_COMMON_ALPHA = 15U,
|
||||
KHR_DF_CHANNEL_COMMON_A = 15U
|
||||
} khr_df_model_channels_e;
|
||||
|
||||
/* Definition of the primary colors in color coordinates.
|
||||
This is implicitly responsible for defining the conversion
|
||||
between RGB an YUV color spaces.
|
||||
LAB and related absolute color models should use
|
||||
KHR_DF_PRIMARIES_CIEXYZ. */
|
||||
typedef enum _khr_df_primaries_e {
|
||||
/* No color primaries defined */
|
||||
KHR_DF_PRIMARIES_UNSPECIFIED = 0U,
|
||||
/* Color primaries of ITU-R BT.709 and sRGB */
|
||||
KHR_DF_PRIMARIES_BT709 = 1U,
|
||||
/* Synonym for KHR_DF_PRIMARIES_BT709 */
|
||||
KHR_DF_PRIMARIES_SRGB = 1U,
|
||||
/* Color primaries of ITU-R BT.601 (625-line EBU variant) */
|
||||
KHR_DF_PRIMARIES_BT601_EBU = 2U,
|
||||
/* Color primaries of ITU-R BT.601 (525-line SMPTE C variant) */
|
||||
KHR_DF_PRIMARIES_BT601_SMPTE = 3U,
|
||||
/* Color primaries of ITU-R BT.2020 */
|
||||
KHR_DF_PRIMARIES_BT2020 = 4U,
|
||||
/* ITU-R BT.2100 uses the same primaries as BT.2020 */
|
||||
KHR_DF_PRIMARIES_BT2100 = 4U,
|
||||
/* CIE theoretical color coordinate space */
|
||||
KHR_DF_PRIMARIES_CIEXYZ = 5U,
|
||||
/* Academy Color Encoding System primaries */
|
||||
KHR_DF_PRIMARIES_ACES = 6U,
|
||||
/* Color primaries of ACEScc */
|
||||
KHR_DF_PRIMARIES_ACESCC = 7U,
|
||||
/* Legacy NTSC 1953 primaries */
|
||||
KHR_DF_PRIMARIES_NTSC1953 = 8U,
|
||||
/* Legacy PAL 525-line primaries */
|
||||
KHR_DF_PRIMARIES_PAL525 = 9U,
|
||||
/* Color primaries of Display P3 */
|
||||
KHR_DF_PRIMARIES_DISPLAYP3 = 10U,
|
||||
/* Color primaries of Adobe RGB (1998) */
|
||||
KHR_DF_PRIMARIES_ADOBERGB = 11U,
|
||||
KHR_DF_PRIMARIES_MAX = 0xFFU
|
||||
} khr_df_primaries_e;
|
||||
|
||||
/* Definition of the optical to digital transfer function
|
||||
("gamma correction"). Most transfer functions are not a pure
|
||||
power function and also include a linear element.
|
||||
LAB and related absolute color representations should use
|
||||
KHR_DF_TRANSFER_UNSPECIFIED.
|
||||
These encodings indicate that the representation has had
|
||||
the corresponding transfer function applied relative to a
|
||||
linear representation; hence to process the linear intensity
|
||||
represented by the value, a corresponding inverse transform
|
||||
must be applied. */
|
||||
typedef enum _khr_df_transfer_e {
|
||||
/* No transfer function defined */
|
||||
KHR_DF_TRANSFER_UNSPECIFIED = 0U,
|
||||
/* Linear transfer function (value proportional to intensity) */
|
||||
KHR_DF_TRANSFER_LINEAR = 1U,
|
||||
/* Perceptually-linear transfer function of sRGB (~2.2); also used for scRGB */
|
||||
KHR_DF_TRANSFER_SRGB = 2U,
|
||||
KHR_DF_TRANSFER_SRGB_EOTF = 2U,
|
||||
KHR_DF_TRANSFER_SCRGB = 2U,
|
||||
KHR_DF_TRANSFER_SCRGB_EOTF = 2U,
|
||||
/* Perceptually-linear transfer function of ITU BT.601, BT.709 and BT.2020 (~1/.45) */
|
||||
KHR_DF_TRANSFER_ITU = 3U,
|
||||
KHR_DF_TRANSFER_ITU_OETF = 3U,
|
||||
KHR_DF_TRANSFER_BT601 = 3U,
|
||||
KHR_DF_TRANSFER_BT601_OETF = 3U,
|
||||
KHR_DF_TRANSFER_BT709 = 3U,
|
||||
KHR_DF_TRANSFER_BT709_OETF = 3U,
|
||||
KHR_DF_TRANSFER_BT2020 = 3U,
|
||||
KHR_DF_TRANSFER_BT2020_OETF = 3U,
|
||||
/* SMTPE170M (digital NTSC) defines an alias for the ITU transfer function (~1/.45) and a linear OOTF */
|
||||
KHR_DF_TRANSFER_SMTPE170M = 3U,
|
||||
KHR_DF_TRANSFER_SMTPE170M_OETF = 3U,
|
||||
KHR_DF_TRANSFER_SMTPE170M_EOTF = 3U,
|
||||
/* Perceptually-linear gamma function of original NTSC (simple 2.2 gamma) */
|
||||
KHR_DF_TRANSFER_NTSC = 4U,
|
||||
KHR_DF_TRANSFER_NTSC_EOTF = 4U,
|
||||
/* Sony S-log used by Sony video cameras */
|
||||
KHR_DF_TRANSFER_SLOG = 5U,
|
||||
KHR_DF_TRANSFER_SLOG_OETF = 5U,
|
||||
/* Sony S-log 2 used by Sony video cameras */
|
||||
KHR_DF_TRANSFER_SLOG2 = 6U,
|
||||
KHR_DF_TRANSFER_SLOG2_OETF = 6U,
|
||||
/* ITU BT.1886 EOTF */
|
||||
KHR_DF_TRANSFER_BT1886 = 7U,
|
||||
KHR_DF_TRANSFER_BT1886_EOTF = 7U,
|
||||
/* ITU BT.2100 HLG OETF (typical scene-referred content), linear light normalized 0..1 */
|
||||
KHR_DF_TRANSFER_HLG_OETF = 8U,
|
||||
/* ITU BT.2100 HLG EOTF (nominal HDR display of HLG content), linear light normalized 0..1 */
|
||||
KHR_DF_TRANSFER_HLG_EOTF = 9U,
|
||||
/* ITU BT.2100 PQ EOTF (typical HDR display-referred PQ content) */
|
||||
KHR_DF_TRANSFER_PQ_EOTF = 10U,
|
||||
/* ITU BT.2100 PQ OETF (nominal scene described by PQ HDR content) */
|
||||
KHR_DF_TRANSFER_PQ_OETF = 11U,
|
||||
/* DCI P3 transfer function */
|
||||
KHR_DF_TRANSFER_DCIP3 = 12U,
|
||||
KHR_DF_TRANSFER_DCIP3_EOTF = 12U,
|
||||
/* Legacy PAL OETF */
|
||||
KHR_DF_TRANSFER_PAL_OETF = 13U,
|
||||
/* Legacy PAL 625-line EOTF */
|
||||
KHR_DF_TRANSFER_PAL625_EOTF = 14U,
|
||||
/* Legacy ST240 transfer function */
|
||||
KHR_DF_TRANSFER_ST240 = 15U,
|
||||
KHR_DF_TRANSFER_ST240_OETF = 15U,
|
||||
KHR_DF_TRANSFER_ST240_EOTF = 15U,
|
||||
/* ACEScc transfer function */
|
||||
KHR_DF_TRANSFER_ACESCC = 16U,
|
||||
KHR_DF_TRANSFER_ACESCC_OETF = 16U,
|
||||
/* ACEScct transfer function */
|
||||
KHR_DF_TRANSFER_ACESCCT = 17U,
|
||||
KHR_DF_TRANSFER_ACESCCT_OETF = 17U,
|
||||
/* Adobe RGB (1998) transfer function */
|
||||
KHR_DF_TRANSFER_ADOBERGB = 18U,
|
||||
KHR_DF_TRANSFER_ADOBERGB_EOTF = 18U,
|
||||
/* Legacy ITU BT.2100 HLG OETF (typical scene-referred content), linear light normalized 0..12 */
|
||||
KHR_DF_TRANSFER_HLG_UNNORMALIZED_OETF = 19U,
|
||||
KHR_DF_TRANSFER_MAX = 0xFFU
|
||||
} khr_df_transfer_e;
|
||||
|
||||
typedef enum _khr_df_flags_e {
|
||||
KHR_DF_FLAG_ALPHA_STRAIGHT = 0U,
|
||||
KHR_DF_FLAG_ALPHA_PREMULTIPLIED = 1U
|
||||
} khr_df_flags_e;
|
||||
|
||||
typedef enum _khr_df_sample_datatype_qualifiers_e {
|
||||
KHR_DF_SAMPLE_DATATYPE_LINEAR = 1U << 4U,
|
||||
KHR_DF_SAMPLE_DATATYPE_EXPONENT = 1U << 5U,
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED = 1U << 6U,
|
||||
KHR_DF_SAMPLE_DATATYPE_FLOAT = 1U << 7U
|
||||
} khr_df_sample_datatype_qualifiers_e;
|
||||
|
||||
#endif
|
71
thirdparty/libktx/external/dfdutils/colourspaces.c
vendored
Normal file
71
thirdparty/libktx/external/dfdutils/colourspaces.c
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
/* Copyright 2019-2020 The Khronos Group Inc.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Helper functions for colourspaces.
|
||||
*/
|
||||
|
||||
#include <KHR/khr_df.h>
|
||||
#include "dfd.h"
|
||||
|
||||
typedef struct s_PrimaryMapping {
|
||||
khr_df_primaries_e dfPrimaryEnum;
|
||||
Primaries primaries;
|
||||
} sPrimaryMapping;
|
||||
|
||||
sPrimaryMapping primaryMap[] = {
|
||||
{ KHR_DF_PRIMARIES_BT709, { 0.640f,0.330f, 0.300f,0.600f, 0.150f,0.060f, 0.3127f,0.3290f}},
|
||||
{ KHR_DF_PRIMARIES_BT601_EBU, { 0.640f,0.330f, 0.290f,0.600f, 0.150f,0.060f, 0.3127f,0.3290f}},
|
||||
{ KHR_DF_PRIMARIES_BT601_SMPTE, { 0.630f,0.340f, 0.310f,0.595f, 0.155f,0.070f, 0.3127f,0.3290f}},
|
||||
{ KHR_DF_PRIMARIES_BT2020, { 0.708f,0.292f, 0.170f,0.797f, 0.131f,0.046f, 0.3127f,0.3290f}},
|
||||
{ KHR_DF_PRIMARIES_CIEXYZ, { 1.0f,0.0f, 0.0f,1.0f, 0.0f,0.0f, 0.0f,1.0f}},
|
||||
{ KHR_DF_PRIMARIES_ACES, { 0.7347f,0.2653f, 0.0f,1.0f, 0.0001f,-0.077f, 0.32168f,0.33767f}},
|
||||
{ KHR_DF_PRIMARIES_ACESCC, { 0.713f,0.293f, 0.165f,0.830f, 0.128f,0.044f, 0.32168f,0.33767f}},
|
||||
{ KHR_DF_PRIMARIES_NTSC1953, { 0.67f,0.33f, 0.21f,0.71f, 0.14f,0.08f, 0.310f,0.316f}},
|
||||
{ KHR_DF_PRIMARIES_PAL525, { 0.630f,0.340f, 0.310f,0.595f, 0.155f,0.070f, 0.3101f,0.3162f}},
|
||||
{ KHR_DF_PRIMARIES_DISPLAYP3, { 0.6800f,0.3200f, 0.2650f,0.69f, 0.1500f,0.0600f, 0.3127f,0.3290f}},
|
||||
{ KHR_DF_PRIMARIES_ADOBERGB, { 0.6400f,0.3300f, 0.2100f,0.71f, 0.1500f,0.0600f, 0.3127f,0.3290f}}};
|
||||
|
||||
/**
|
||||
* @brief Map a set of primaries to a KDFS primaries enum.
|
||||
*
|
||||
* @param[in] p pointer to a Primaries struct filled in with the primary values.
|
||||
* @param[in] latitude tolerance to use while matching. A suitable value might be 0.002
|
||||
* but it depends on the application.
|
||||
*/
|
||||
khr_df_primaries_e findMapping(const Primaries *p, float latitude) {
|
||||
unsigned int i;
|
||||
for (i = 0; i < sizeof(primaryMap)/sizeof(sPrimaryMapping); ++i) {
|
||||
if (primaryMap[i].primaries.Rx - p->Rx <= latitude && p->Rx - primaryMap[i].primaries.Rx <= latitude &&
|
||||
primaryMap[i].primaries.Gx - p->Gx <= latitude && p->Gx - primaryMap[i].primaries.Gx <= latitude &&
|
||||
primaryMap[i].primaries.Bx - p->Bx <= latitude && p->Bx - primaryMap[i].primaries.Bx <= latitude &&
|
||||
primaryMap[i].primaries.Wx - p->Wx <= latitude && p->Wx - primaryMap[i].primaries.Wx <= latitude) {
|
||||
return primaryMap[i].dfPrimaryEnum;
|
||||
}
|
||||
}
|
||||
/* No match */
|
||||
return KHR_DF_PRIMARIES_UNSPECIFIED;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the primaries corresponding to a KDFS primaries enum.
|
||||
*
|
||||
* @param[in] primaries the enum identifying the KDFS primaries.
|
||||
* @param[out] p pointer to a Primaries struct that will
|
||||
* be filled with the primary values.
|
||||
*/
|
||||
bool getPrimaries(khr_df_primaries_e primaries, Primaries *p) {
|
||||
unsigned int i;
|
||||
for (i = 0; i < sizeof(primaryMap)/sizeof(sPrimaryMapping); ++i) {
|
||||
if (primaryMap[i].dfPrimaryEnum == primaries) {
|
||||
*p = primaryMap[i].primaries;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/* No match */
|
||||
return false;
|
||||
}
|
809
thirdparty/libktx/external/dfdutils/createdfd.c
vendored
Normal file
809
thirdparty/libktx/external/dfdutils/createdfd.c
vendored
Normal file
@@ -0,0 +1,809 @@
|
||||
/* -*- tab-width: 4; -*- */
|
||||
/* vi: set sw=2 ts=4 expandtab: */
|
||||
|
||||
/* Copyright 2019-2020 The Khronos Group Inc.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Utilities for creating data format descriptors.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Author: Andrew Garrard
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <KHR/khr_df.h>
|
||||
|
||||
#include "dfd.h"
|
||||
|
||||
typedef enum { i_COLOR, i_NON_COLOR } channels_infotype;
|
||||
|
||||
static uint32_t *writeHeader(int numSamples, int bytes, int suffix,
|
||||
channels_infotype infotype)
|
||||
{
|
||||
uint32_t *DFD = (uint32_t *) malloc(sizeof(uint32_t) *
|
||||
(1 + KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS));
|
||||
uint32_t* BDFD = DFD+1;
|
||||
DFD[0] = sizeof(uint32_t) *
|
||||
(1 + KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS);
|
||||
BDFD[KHR_DF_WORD_VENDORID] =
|
||||
(KHR_DF_VENDORID_KHRONOS << KHR_DF_SHIFT_VENDORID) |
|
||||
(KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT << KHR_DF_SHIFT_DESCRIPTORTYPE);
|
||||
BDFD[KHR_DF_WORD_VERSIONNUMBER] =
|
||||
(KHR_DF_VERSIONNUMBER_LATEST << KHR_DF_SHIFT_VERSIONNUMBER) |
|
||||
(((uint32_t)sizeof(uint32_t) *
|
||||
(KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS)
|
||||
<< KHR_DF_SHIFT_DESCRIPTORBLOCKSIZE));
|
||||
BDFD[KHR_DF_WORD_MODEL] =
|
||||
((KHR_DF_MODEL_RGBSDA << KHR_DF_SHIFT_MODEL) | /* Only supported model */
|
||||
(KHR_DF_FLAG_ALPHA_STRAIGHT << KHR_DF_SHIFT_FLAGS));
|
||||
if (infotype == i_COLOR) {
|
||||
BDFD[KHR_DF_WORD_PRIMARIES] |= KHR_DF_PRIMARIES_BT709 << KHR_DF_SHIFT_PRIMARIES; /* Assumed */
|
||||
} else {
|
||||
BDFD[KHR_DF_WORD_PRIMARIES] |= KHR_DF_PRIMARIES_UNSPECIFIED << KHR_DF_SHIFT_PRIMARIES;
|
||||
}
|
||||
if (suffix == s_SRGB) {
|
||||
BDFD[KHR_DF_WORD_TRANSFER] |= KHR_DF_TRANSFER_SRGB << KHR_DF_SHIFT_TRANSFER;
|
||||
} else {
|
||||
BDFD[KHR_DF_WORD_TRANSFER] |= KHR_DF_TRANSFER_LINEAR << KHR_DF_SHIFT_TRANSFER;
|
||||
}
|
||||
BDFD[KHR_DF_WORD_TEXELBLOCKDIMENSION0] = 0; /* Only 1x1x1x1 texel blocks supported */
|
||||
BDFD[KHR_DF_WORD_BYTESPLANE0] = bytes; /* bytesPlane0 = bytes, bytesPlane3..1 = 0 */
|
||||
BDFD[KHR_DF_WORD_BYTESPLANE4] = 0; /* bytesPlane7..5 = 0 */
|
||||
return DFD;
|
||||
}
|
||||
|
||||
static uint32_t setChannelFlags(uint32_t channel, enum VkSuffix suffix)
|
||||
{
|
||||
switch (suffix) {
|
||||
case s_UNORM: break;
|
||||
case s_SNORM:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
break;
|
||||
case s_USCALED: break;
|
||||
case s_SSCALED:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
break;
|
||||
case s_UINT: break;
|
||||
case s_SINT:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
break;
|
||||
case s_SFLOAT:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_FLOAT |
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
break;
|
||||
case s_UFLOAT:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_FLOAT;
|
||||
break;
|
||||
case s_SRGB:
|
||||
if (channel == KHR_DF_CHANNEL_RGBSDA_ALPHA) {
|
||||
channel |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
|
||||
}
|
||||
break;
|
||||
case s_SFIXED5:
|
||||
channel |=
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
break;
|
||||
}
|
||||
return channel;
|
||||
}
|
||||
|
||||
static void writeSample(uint32_t *DFD, int sampleNo, int channel,
|
||||
int bits, int offset,
|
||||
int topSample, int bottomSample, enum VkSuffix suffix)
|
||||
{
|
||||
// Use this to avoid type-punning complaints from the gcc optimizer
|
||||
// with -Wall.
|
||||
union {
|
||||
uint32_t i;
|
||||
float f;
|
||||
} lower, upper;
|
||||
uint32_t *sample = DFD + 1 + KHR_DF_WORD_SAMPLESTART + sampleNo * KHR_DF_WORD_SAMPLEWORDS;
|
||||
|
||||
if (channel == 3) channel = KHR_DF_CHANNEL_RGBSDA_ALPHA;
|
||||
channel = setChannelFlags(channel, suffix);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_BITOFFSET] =
|
||||
(offset << KHR_DF_SAMPLESHIFT_BITOFFSET) |
|
||||
((bits - 1) << KHR_DF_SAMPLESHIFT_BITLENGTH) |
|
||||
(channel << KHR_DF_SAMPLESHIFT_CHANNELID);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEPOSITION_ALL] = 0;
|
||||
|
||||
switch (suffix) {
|
||||
case s_UNORM:
|
||||
case s_SRGB:
|
||||
default:
|
||||
if (bits > 32) {
|
||||
upper.i = 0xFFFFFFFFU;
|
||||
} else {
|
||||
upper.i = (uint32_t)((1U << bits) - 1U);
|
||||
}
|
||||
lower.i = 0U;
|
||||
break;
|
||||
case s_SNORM:
|
||||
if (bits > 32) {
|
||||
upper.i = 0x7FFFFFFF;
|
||||
} else {
|
||||
upper.i = topSample ? (1U << (bits - 1)) - 1 : (1U << bits) - 1;
|
||||
}
|
||||
lower.i = ~upper.i;
|
||||
if (bottomSample) lower.i += 1;
|
||||
break;
|
||||
case s_USCALED:
|
||||
case s_UINT:
|
||||
upper.i = bottomSample ? 1U : 0U;
|
||||
lower.i = 0U;
|
||||
break;
|
||||
case s_SSCALED:
|
||||
case s_SINT:
|
||||
upper.i = bottomSample ? 1U : 0U;
|
||||
lower.i = ~0U;
|
||||
break;
|
||||
case s_SFLOAT:
|
||||
upper.f = 1.0f;
|
||||
lower.f = -1.0f;
|
||||
break;
|
||||
case s_UFLOAT:
|
||||
upper.f = 1.0f;
|
||||
lower.f = 0.0f;
|
||||
break;
|
||||
case s_SFIXED5:
|
||||
assert(bits == 16 && "Format with this suffix must be 16 bits per channel.");
|
||||
upper.i = 32;
|
||||
lower.i = ~upper.i + 1; // -32
|
||||
}
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLELOWER] = lower.i;
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEUPPER] = upper.i;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for an unpacked format.
|
||||
*
|
||||
* @param bigEndian Set to 1 for big-endian byte ordering and
|
||||
0 for little-endian byte ordering.
|
||||
* @param numChannels The number of color channels.
|
||||
* @param bytes The number of bytes per channel.
|
||||
* @param redBlueSwap Normally channels appear in consecutive R, G, B, A order
|
||||
* in memory; redBlueSwap inverts red and blue, allowing
|
||||
* B, G, R, A.
|
||||
* @param suffix Indicates the format suffix for the type.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDUnpacked(int bigEndian, int numChannels, int bytes,
|
||||
int redBlueSwap, enum VkSuffix suffix)
|
||||
{
|
||||
uint32_t *DFD;
|
||||
if (bigEndian) {
|
||||
int channelCounter, channelByte;
|
||||
/* Number of samples = number of channels * bytes per channel */
|
||||
DFD = writeHeader(numChannels * bytes, numChannels * bytes, suffix, i_COLOR);
|
||||
/* First loop over the channels */
|
||||
for (channelCounter = 0; channelCounter < numChannels; ++channelCounter) {
|
||||
int channel = channelCounter;
|
||||
if (redBlueSwap && (channel == 0 || channel == 2)) {
|
||||
channel ^= 2;
|
||||
}
|
||||
/* Loop over the bytes that constitute a channel */
|
||||
for (channelByte = 0; channelByte < bytes; ++channelByte) {
|
||||
writeSample(DFD, channelCounter * bytes + channelByte, channel,
|
||||
8, 8 * (channelCounter * bytes + bytes - channelByte - 1),
|
||||
channelByte == bytes-1, channelByte == 0, suffix);
|
||||
}
|
||||
}
|
||||
|
||||
} else { /* Little-endian */
|
||||
|
||||
int sampleCounter;
|
||||
/* One sample per channel */
|
||||
DFD = writeHeader(numChannels, numChannels * bytes, suffix, i_COLOR);
|
||||
for (sampleCounter = 0; sampleCounter < numChannels; ++sampleCounter) {
|
||||
int channel = sampleCounter;
|
||||
if (redBlueSwap && (channel == 0 || channel == 2)) {
|
||||
channel ^= 2;
|
||||
}
|
||||
writeSample(DFD, sampleCounter, channel,
|
||||
8 * bytes, 8 * sampleCounter * bytes,
|
||||
1, 1, suffix);
|
||||
}
|
||||
}
|
||||
return DFD;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for a packed format.
|
||||
*
|
||||
* @param bigEndian Big-endian flag: Set to 1 for big-endian byte ordering and
|
||||
* 0 for little-endian byte ordering.
|
||||
* @param numChannels The number of color channels.
|
||||
* @param bits[] An array of length numChannels.
|
||||
* Each entry is the number of bits composing the channel, in
|
||||
* order starting at bit 0 of the packed type.
|
||||
* @param shiftBits[] An array of length numChannels.
|
||||
* Each entry is the number of bits each channel is shifted
|
||||
* and thus padded with insignificant bits.
|
||||
* @param channels[] An array of length numChannels.
|
||||
* Each entry enumerates the channel type: 0 = red, 1 = green,
|
||||
* 2 = blue, 15 = alpha, in order starting at bit 0 of the
|
||||
* packed type. These values match channel IDs for RGBSDA in
|
||||
* the Khronos Data Format header. To simplify iteration
|
||||
* through channels, channel id 3 is a synonym for alpha.
|
||||
* @param suffix Indicates the format suffix for the type.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDPackedShifted(int bigEndian, int numChannels,
|
||||
int bits[], int shiftBits[], int channels[],
|
||||
enum VkSuffix suffix)
|
||||
{
|
||||
uint32_t *DFD = 0;
|
||||
if (numChannels == 6) {
|
||||
/* Special case E5B9G9R9 */
|
||||
DFD = writeHeader(numChannels, 4, s_UFLOAT, i_COLOR);
|
||||
writeSample(DFD, 0, 0,
|
||||
9, 0,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 0, SAMPLEUPPER, 8448);
|
||||
writeSample(DFD, 1, 0 | KHR_DF_SAMPLE_DATATYPE_EXPONENT,
|
||||
5, 27,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 1, SAMPLELOWER, 15);
|
||||
KHR_DFDSETSVAL((DFD+1), 1, SAMPLEUPPER, 31);
|
||||
writeSample(DFD, 2, 1,
|
||||
9, 9,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 2, SAMPLEUPPER, 8448);
|
||||
writeSample(DFD, 3, 1 | KHR_DF_SAMPLE_DATATYPE_EXPONENT,
|
||||
5, 27,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 3, SAMPLELOWER, 15);
|
||||
KHR_DFDSETSVAL((DFD+1), 3, SAMPLEUPPER, 31);
|
||||
writeSample(DFD, 4, 2,
|
||||
9, 18,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 4, SAMPLEUPPER, 8448);
|
||||
writeSample(DFD, 5, 2 | KHR_DF_SAMPLE_DATATYPE_EXPONENT,
|
||||
5, 27,
|
||||
1, 1, s_UNORM);
|
||||
KHR_DFDSETSVAL((DFD+1), 5, SAMPLELOWER, 15);
|
||||
KHR_DFDSETSVAL((DFD+1), 5, SAMPLEUPPER, 31);
|
||||
} else if (bigEndian) {
|
||||
/* No packed format is larger than 32 bits. */
|
||||
/* No packed channel crosses more than two bytes. */
|
||||
int totalBits = 0;
|
||||
int bitChannel[32];
|
||||
int beChannelStart[4];
|
||||
int channelCounter;
|
||||
int bitOffset = 0;
|
||||
int BEMask;
|
||||
int numSamples = numChannels;
|
||||
int sampleCounter;
|
||||
for (channelCounter = 0; channelCounter < numChannels; ++channelCounter) {
|
||||
beChannelStart[channelCounter] = totalBits;
|
||||
totalBits += shiftBits[channelCounter] + bits[channelCounter];
|
||||
}
|
||||
BEMask = (totalBits - 1) & 0x18;
|
||||
for (channelCounter = 0; channelCounter < numChannels; ++channelCounter) {
|
||||
bitOffset += shiftBits[channelCounter];
|
||||
bitChannel[bitOffset ^ BEMask] = channelCounter;
|
||||
if (((bitOffset + bits[channelCounter] - 1) & ~7) != (bitOffset & ~7)) {
|
||||
/* Continuation sample */
|
||||
bitChannel[((bitOffset + bits[channelCounter] - 1) & ~7) ^ BEMask] = channelCounter;
|
||||
numSamples++;
|
||||
}
|
||||
bitOffset += bits[channelCounter];
|
||||
}
|
||||
DFD = writeHeader(numSamples, totalBits >> 3, suffix, i_COLOR);
|
||||
|
||||
sampleCounter = 0;
|
||||
for (bitOffset = 0; bitOffset < totalBits;) {
|
||||
if (bitChannel[bitOffset] == -1) {
|
||||
/* Done this bit, so this is the lower half of something. */
|
||||
/* We must therefore jump to the end of the byte and continue. */
|
||||
bitOffset = (bitOffset + 8) & ~7;
|
||||
} else {
|
||||
/* Start of a channel? */
|
||||
int thisChannel = bitChannel[bitOffset];
|
||||
if ((beChannelStart[thisChannel] ^ BEMask) == bitOffset) {
|
||||
/* Must be just one sample if we hit it first. */
|
||||
writeSample(DFD, sampleCounter++, channels[thisChannel],
|
||||
bits[thisChannel], bitOffset,
|
||||
1, 1, suffix);
|
||||
bitOffset += bits[thisChannel];
|
||||
} else {
|
||||
/* Two samples. Move to the end of the first one we hit when we're done. */
|
||||
int firstSampleBits = 8 - (beChannelStart[thisChannel] & 0x7); /* Rest of the byte */
|
||||
int secondSampleBits = bits[thisChannel] - firstSampleBits; /* Rest of the bits */
|
||||
writeSample(DFD, sampleCounter++, channels[thisChannel],
|
||||
firstSampleBits, beChannelStart[thisChannel] ^ BEMask,
|
||||
0, 1, suffix);
|
||||
/* Mark that we've already handled this sample */
|
||||
bitChannel[beChannelStart[thisChannel] ^ BEMask] = -1;
|
||||
writeSample(DFD, sampleCounter++, channels[thisChannel],
|
||||
secondSampleBits, bitOffset,
|
||||
1, 0, suffix);
|
||||
bitOffset += secondSampleBits;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} else { /* Little-endian */
|
||||
|
||||
int sampleCounter;
|
||||
int totalBits = 0;
|
||||
int bitOffset = 0;
|
||||
for (sampleCounter = 0; sampleCounter < numChannels; ++sampleCounter) {
|
||||
totalBits += shiftBits[sampleCounter] + bits[sampleCounter];
|
||||
}
|
||||
|
||||
/* One sample per channel */
|
||||
DFD = writeHeader(numChannels, totalBits >> 3, suffix, i_COLOR);
|
||||
for (sampleCounter = 0; sampleCounter < numChannels; ++sampleCounter) {
|
||||
bitOffset += shiftBits[sampleCounter];
|
||||
writeSample(DFD, sampleCounter, channels[sampleCounter],
|
||||
bits[sampleCounter], bitOffset,
|
||||
1, 1, suffix);
|
||||
bitOffset += bits[sampleCounter];
|
||||
}
|
||||
}
|
||||
return DFD;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for a packed format.
|
||||
*
|
||||
* @param bigEndian Big-endian flag: Set to 1 for big-endian byte ordering and
|
||||
* 0 for little-endian byte ordering.
|
||||
* @param numChannels The number of color channels.
|
||||
* @param bits[] An array of length numChannels.
|
||||
* Each entry is the number of bits composing the channel, in
|
||||
* order starting at bit 0 of the packed type.
|
||||
* @param channels[] An array of length numChannels.
|
||||
* Each entry enumerates the channel type: 0 = red, 1 = green,
|
||||
* 2 = blue, 15 = alpha, in order starting at bit 0 of the
|
||||
* packed type. These values match channel IDs for RGBSDA in
|
||||
* the Khronos Data Format header. To simplify iteration
|
||||
* through channels, channel id 3 is a synonym for alpha.
|
||||
* @param suffix Indicates the format suffix for the type.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDPacked(int bigEndian, int numChannels,
|
||||
int bits[], int channels[],
|
||||
enum VkSuffix suffix) {
|
||||
assert(numChannels <= 6);
|
||||
int shiftBits[] = {0, 0, 0, 0, 0, 0};
|
||||
return createDFDPackedShifted(bigEndian, numChannels, bits, shiftBits, channels, suffix);
|
||||
}
|
||||
|
||||
uint32_t *createDFD422(int bigEndian, int numSamples,
|
||||
int bits[], int shiftBits[], int channels[],
|
||||
int position_xs[], int position_ys[],
|
||||
enum VkSuffix suffix) {
|
||||
assert(!bigEndian); (void) bigEndian;
|
||||
assert(suffix == s_UNORM); (void) suffix;
|
||||
|
||||
int totalBits = 0;
|
||||
for (int i = 0; i < numSamples; ++i)
|
||||
totalBits += shiftBits[i] + bits[i];
|
||||
assert(totalBits % 8 == 0);
|
||||
|
||||
uint32_t BDFDSize = sizeof(uint32_t) * (KHR_DF_WORD_SAMPLESTART + numSamples * KHR_DF_WORD_SAMPLEWORDS);
|
||||
uint32_t DFDSize = sizeof(uint32_t) + BDFDSize;
|
||||
uint32_t *DFD = (uint32_t *) malloc(DFDSize);
|
||||
memset(DFD, 0, DFDSize);
|
||||
DFD[0] = DFDSize;
|
||||
uint32_t *BDFD = DFD + 1;
|
||||
KHR_DFDSETVAL(BDFD, VENDORID, KHR_DF_VENDORID_KHRONOS);
|
||||
KHR_DFDSETVAL(BDFD, DESCRIPTORTYPE, KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT);
|
||||
KHR_DFDSETVAL(BDFD, VERSIONNUMBER, KHR_DF_VERSIONNUMBER_LATEST);
|
||||
KHR_DFDSETVAL(BDFD, DESCRIPTORBLOCKSIZE, BDFDSize);
|
||||
KHR_DFDSETVAL(BDFD, MODEL, KHR_DF_MODEL_YUVSDA);
|
||||
KHR_DFDSETVAL(BDFD, PRIMARIES, KHR_DF_PRIMARIES_UNSPECIFIED);
|
||||
KHR_DFDSETVAL(BDFD, TRANSFER, KHR_DF_TRANSFER_LINEAR);
|
||||
KHR_DFDSETVAL(BDFD, FLAGS, KHR_DF_FLAG_ALPHA_STRAIGHT);
|
||||
KHR_DFDSETVAL(BDFD, TEXELBLOCKDIMENSION0, 2 - 1); // 422 contains 2 x 1 blocks
|
||||
KHR_DFDSETVAL(BDFD, TEXELBLOCKDIMENSION1, 1 - 1);
|
||||
KHR_DFDSETVAL(BDFD, TEXELBLOCKDIMENSION2, 1 - 1);
|
||||
KHR_DFDSETVAL(BDFD, TEXELBLOCKDIMENSION3, 1 - 1);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE0, totalBits / 8);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE1, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE2, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE3, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE4, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE5, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE6, 0);
|
||||
KHR_DFDSETVAL(BDFD, BYTESPLANE7, 0);
|
||||
|
||||
int bitOffset = 0;
|
||||
for (int i = 0; i < numSamples; ++i) {
|
||||
bitOffset += shiftBits[i];
|
||||
KHR_DFDSETSVAL(BDFD, i, BITOFFSET, bitOffset);
|
||||
KHR_DFDSETSVAL(BDFD, i, BITLENGTH, bits[i] - 1);
|
||||
KHR_DFDSETSVAL(BDFD, i, CHANNELID, channels[i]);
|
||||
KHR_DFDSETSVAL(BDFD, i, QUALIFIERS, 0); // None of: FLOAT, SIGNED, EXPONENT, LINEAR
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLEPOSITION0, position_xs[i]);
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLEPOSITION1, position_ys[i]);
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLEPOSITION2, 0);
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLEPOSITION3, 0);
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLELOWER, 0);
|
||||
KHR_DFDSETSVAL(BDFD, i, SAMPLEUPPER, (1u << bits[i]) - 1u);
|
||||
bitOffset += bits[i];
|
||||
}
|
||||
|
||||
return DFD;
|
||||
}
|
||||
|
||||
static khr_df_model_e compModelMapping[] = {
|
||||
KHR_DF_MODEL_BC1A, /*!< BC1, aka DXT1, no alpha. */
|
||||
KHR_DF_MODEL_BC1A, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
KHR_DF_MODEL_BC2, /*!< BC2, aka DXT2 and DXT3. */
|
||||
KHR_DF_MODEL_BC3, /*!< BC3, aka DXT4 and DXT5. */
|
||||
KHR_DF_MODEL_BC4, /*!< BC4. */
|
||||
KHR_DF_MODEL_BC5, /*!< BC5. */
|
||||
KHR_DF_MODEL_BC6H, /*!< BC6h HDR format. */
|
||||
KHR_DF_MODEL_BC7, /*!< BC7. */
|
||||
KHR_DF_MODEL_ETC2, /*!< ETC2 no alpha. */
|
||||
KHR_DF_MODEL_ETC2, /*!< ETC2 punch-through alpha. */
|
||||
KHR_DF_MODEL_ETC2, /*!< ETC2 independent alpha. */
|
||||
KHR_DF_MODEL_ETC2, /*!< R11 ETC2 single-channel. */
|
||||
KHR_DF_MODEL_ETC2, /*!< R11G11 ETC2 dual-channel. */
|
||||
KHR_DF_MODEL_ASTC, /*!< ASTC. */
|
||||
KHR_DF_MODEL_ETC1S, /*!< ETC1S. */
|
||||
KHR_DF_MODEL_PVRTC, /*!< PVRTC(1). */
|
||||
KHR_DF_MODEL_PVRTC2 /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static uint32_t compSampleCount[] = {
|
||||
1U, /*!< BC1, aka DXT1, no alpha. */
|
||||
1U, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
2U, /*!< BC2, aka DXT2 and DXT3. */
|
||||
2U, /*!< BC3, aka DXT4 and DXT5. */
|
||||
1U, /*!< BC4. */
|
||||
2U, /*!< BC5. */
|
||||
1U, /*!< BC6h HDR format. */
|
||||
1U, /*!< BC7. */
|
||||
1U, /*!< ETC2 no alpha. */
|
||||
2U, /*!< ETC2 punch-through alpha. */
|
||||
2U, /*!< ETC2 independent alpha. */
|
||||
1U, /*!< R11 ETC2 single-channel. */
|
||||
2U, /*!< R11G11 ETC2 dual-channel. */
|
||||
1U, /*!< ASTC. */
|
||||
1U, /*!< ETC1S. */
|
||||
1U, /*!< PVRTC. */
|
||||
1U /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static khr_df_model_channels_e compFirstChannel[] = {
|
||||
KHR_DF_CHANNEL_BC1A_COLOR, /*!< BC1, aka DXT1, no alpha. */
|
||||
KHR_DF_CHANNEL_BC1A_ALPHAPRESENT, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
KHR_DF_CHANNEL_BC2_ALPHA, /*!< BC2, aka DXT2 and DXT3. */
|
||||
KHR_DF_CHANNEL_BC3_ALPHA, /*!< BC3, aka DXT4 and DXT5. */
|
||||
KHR_DF_CHANNEL_BC4_DATA, /*!< BC4. */
|
||||
KHR_DF_CHANNEL_BC5_RED, /*!< BC5. */
|
||||
KHR_DF_CHANNEL_BC6H_COLOR, /*!< BC6h HDR format. */
|
||||
KHR_DF_CHANNEL_BC7_COLOR, /*!< BC7. */
|
||||
KHR_DF_CHANNEL_ETC2_COLOR, /*!< ETC2 no alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_COLOR, /*!< ETC2 punch-through alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_ALPHA, /*!< ETC2 independent alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_RED, /*!< R11 ETC2 single-channel. */
|
||||
KHR_DF_CHANNEL_ETC2_RED, /*!< R11G11 ETC2 dual-channel. */
|
||||
KHR_DF_CHANNEL_ASTC_DATA, /*!< ASTC. */
|
||||
KHR_DF_CHANNEL_ETC1S_RGB, /*!< ETC1S. */
|
||||
KHR_DF_CHANNEL_PVRTC_COLOR, /*!< PVRTC. */
|
||||
KHR_DF_CHANNEL_PVRTC2_COLOR /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static khr_df_model_channels_e compSecondChannel[] = {
|
||||
KHR_DF_CHANNEL_BC1A_COLOR, /*!< BC1, aka DXT1, no alpha. */
|
||||
KHR_DF_CHANNEL_BC1A_ALPHAPRESENT, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
KHR_DF_CHANNEL_BC2_COLOR, /*!< BC2, aka DXT2 and DXT3. */
|
||||
KHR_DF_CHANNEL_BC3_COLOR, /*!< BC3, aka DXT4 and DXT5. */
|
||||
KHR_DF_CHANNEL_BC4_DATA, /*!< BC4. */
|
||||
KHR_DF_CHANNEL_BC5_GREEN, /*!< BC5. */
|
||||
KHR_DF_CHANNEL_BC6H_COLOR, /*!< BC6h HDR format. */
|
||||
KHR_DF_CHANNEL_BC7_COLOR, /*!< BC7. */
|
||||
KHR_DF_CHANNEL_ETC2_COLOR, /*!< ETC2 no alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_ALPHA, /*!< ETC2 punch-through alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_COLOR, /*!< ETC2 independent alpha. */
|
||||
KHR_DF_CHANNEL_ETC2_RED, /*!< R11 ETC2 single-channel. */
|
||||
KHR_DF_CHANNEL_ETC2_GREEN, /*!< R11G11 ETC2 dual-channel. */
|
||||
KHR_DF_CHANNEL_ASTC_DATA, /*!< ASTC. */
|
||||
KHR_DF_CHANNEL_ETC1S_RGB, /*!< ETC1S. */
|
||||
KHR_DF_CHANNEL_PVRTC_COLOR, /*!< PVRTC. */
|
||||
KHR_DF_CHANNEL_PVRTC2_COLOR /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static uint32_t compSecondChannelOffset[] = {
|
||||
0U, /*!< BC1, aka DXT1, no alpha. */
|
||||
0U, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
64U, /*!< BC2, aka DXT2 and DXT3. */
|
||||
64U, /*!< BC3, aka DXT4 and DXT5. */
|
||||
0U, /*!< BC4. */
|
||||
64U, /*!< BC5. */
|
||||
0U, /*!< BC6h HDR format. */
|
||||
0U, /*!< BC7. */
|
||||
0U, /*!< ETC2 no alpha. */
|
||||
0U, /*!< ETC2 punch-through alpha. */
|
||||
64U, /*!< ETC2 independent alpha. */
|
||||
0U, /*!< R11 ETC2 single-channel. */
|
||||
64U, /*!< R11G11 ETC2 dual-channel. */
|
||||
0U, /*!< ASTC. */
|
||||
0U, /*!< ETC1S. */
|
||||
0U, /*!< PVRTC. */
|
||||
0U /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static uint32_t compChannelBits[] = {
|
||||
64U, /*!< BC1, aka DXT1, no alpha. */
|
||||
64U, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
64U, /*!< BC2, aka DXT2 and DXT3. */
|
||||
64U, /*!< BC3, aka DXT4 and DXT5. */
|
||||
64U, /*!< BC4. */
|
||||
64U, /*!< BC5. */
|
||||
128U, /*!< BC6h HDR format. */
|
||||
128U, /*!< BC7. */
|
||||
64U, /*!< ETC2 no alpha. */
|
||||
64U, /*!< ETC2 punch-through alpha. */
|
||||
64U, /*!< ETC2 independent alpha. */
|
||||
64U, /*!< R11 ETC2 single-channel. */
|
||||
64U, /*!< R11G11 ETC2 dual-channel. */
|
||||
128U, /*!< ASTC. */
|
||||
64U, /*!< ETC1S. */
|
||||
64U, /*!< PVRTC. */
|
||||
64U /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
static uint32_t compBytes[] = {
|
||||
8U, /*!< BC1, aka DXT1, no alpha. */
|
||||
8U, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
16U, /*!< BC2, aka DXT2 and DXT3. */
|
||||
16U, /*!< BC3, aka DXT4 and DXT5. */
|
||||
8U, /*!< BC4. */
|
||||
16U, /*!< BC5. */
|
||||
16U, /*!< BC6h HDR format. */
|
||||
16U, /*!< BC7. */
|
||||
8U, /*!< ETC2 no alpha. */
|
||||
8U, /*!< ETC2 punch-through alpha. */
|
||||
16U, /*!< ETC2 independent alpha. */
|
||||
8U, /*!< R11 ETC2 single-channel. */
|
||||
16U, /*!< R11G11 ETC2 dual-channel. */
|
||||
16U, /*!< ASTC. */
|
||||
8U, /*!< ETC1S. */
|
||||
8U, /*!< PVRTC. */
|
||||
8U /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for a compressed format.
|
||||
*
|
||||
* @param compScheme Vulkan-style compression scheme enumeration.
|
||||
* @param bwidth Block width in texel coordinates.
|
||||
* @param bheight Block height in texel coordinates.
|
||||
* @param bdepth Block depth in texel coordinates.
|
||||
* @author Mark Callow, Edgewise Consulting.
|
||||
* @param suffix Indicates the format suffix for the type.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDCompressed(enum VkCompScheme compScheme, int bwidth, int bheight, int bdepth,
|
||||
enum VkSuffix suffix)
|
||||
{
|
||||
uint32_t *DFD = 0;
|
||||
uint32_t numSamples = compSampleCount[compScheme];
|
||||
uint32_t* BDFD;
|
||||
uint32_t *sample;
|
||||
uint32_t channel;
|
||||
// Use union to avoid type-punning complaints from gcc optimizer
|
||||
// with -Wall.
|
||||
union {
|
||||
uint32_t i;
|
||||
float f;
|
||||
} lower, upper;
|
||||
|
||||
DFD = (uint32_t *) malloc(sizeof(uint32_t) *
|
||||
(1 + KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS));
|
||||
BDFD = DFD+1;
|
||||
DFD[0] = sizeof(uint32_t) *
|
||||
(1 + KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS);
|
||||
BDFD[KHR_DF_WORD_VENDORID] =
|
||||
(KHR_DF_VENDORID_KHRONOS << KHR_DF_SHIFT_VENDORID) |
|
||||
(KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT << KHR_DF_SHIFT_DESCRIPTORTYPE);
|
||||
BDFD[KHR_DF_WORD_VERSIONNUMBER] =
|
||||
(KHR_DF_VERSIONNUMBER_LATEST << KHR_DF_SHIFT_VERSIONNUMBER) |
|
||||
(((uint32_t)sizeof(uint32_t) *
|
||||
(KHR_DF_WORD_SAMPLESTART +
|
||||
numSamples * KHR_DF_WORD_SAMPLEWORDS)
|
||||
<< KHR_DF_SHIFT_DESCRIPTORBLOCKSIZE));
|
||||
BDFD[KHR_DF_WORD_MODEL] =
|
||||
((compModelMapping[compScheme] << KHR_DF_SHIFT_MODEL) |
|
||||
(KHR_DF_PRIMARIES_BT709 << KHR_DF_SHIFT_PRIMARIES) | /* Assumed */
|
||||
(KHR_DF_FLAG_ALPHA_STRAIGHT << KHR_DF_SHIFT_FLAGS));
|
||||
|
||||
if (suffix == s_SRGB) {
|
||||
BDFD[KHR_DF_WORD_TRANSFER] |= KHR_DF_TRANSFER_SRGB << KHR_DF_SHIFT_TRANSFER;
|
||||
} else {
|
||||
BDFD[KHR_DF_WORD_TRANSFER] |= KHR_DF_TRANSFER_LINEAR << KHR_DF_SHIFT_TRANSFER;
|
||||
}
|
||||
BDFD[KHR_DF_WORD_TEXELBLOCKDIMENSION0] =
|
||||
(bwidth - 1) | ((bheight - 1) << KHR_DF_SHIFT_TEXELBLOCKDIMENSION1) | ((bdepth - 1) << KHR_DF_SHIFT_TEXELBLOCKDIMENSION2);
|
||||
/* bytesPlane0 = bytes, bytesPlane3..1 = 0 */
|
||||
BDFD[KHR_DF_WORD_BYTESPLANE0] = compBytes[compScheme];
|
||||
BDFD[KHR_DF_WORD_BYTESPLANE4] = 0; /* bytesPlane7..5 = 0 */
|
||||
|
||||
sample = BDFD + KHR_DF_WORD_SAMPLESTART;
|
||||
channel = compFirstChannel[compScheme];
|
||||
channel = setChannelFlags(channel, suffix);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_BITOFFSET] =
|
||||
(0 << KHR_DF_SAMPLESHIFT_BITOFFSET) |
|
||||
((compChannelBits[compScheme] - 1) << KHR_DF_SAMPLESHIFT_BITLENGTH) |
|
||||
(channel << KHR_DF_SAMPLESHIFT_CHANNELID);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEPOSITION_ALL] = 0;
|
||||
switch (suffix) {
|
||||
case s_UNORM:
|
||||
case s_SRGB:
|
||||
default:
|
||||
upper.i = 0xFFFFFFFFU;
|
||||
lower.i = 0U;
|
||||
break;
|
||||
case s_SNORM:
|
||||
upper.i = 0x7FFFFFFF;
|
||||
lower.i = ~upper.i;
|
||||
break;
|
||||
case s_USCALED:
|
||||
case s_UINT:
|
||||
upper.i = 1U;
|
||||
lower.i = 0U;
|
||||
break;
|
||||
case s_SSCALED:
|
||||
case s_SINT:
|
||||
upper.i = 1U;
|
||||
lower.i = ~0U;
|
||||
break;
|
||||
case s_SFLOAT:
|
||||
upper.f = 1.0f;
|
||||
lower.f = -1.0f;
|
||||
break;
|
||||
case s_UFLOAT:
|
||||
upper.f = 1.0f;
|
||||
lower.f = 0.0f;
|
||||
break;
|
||||
}
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLELOWER] = lower.i;
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEUPPER] = upper.i;
|
||||
|
||||
if (compSampleCount[compScheme] > 1) {
|
||||
sample += KHR_DF_WORD_SAMPLEWORDS;
|
||||
channel = compSecondChannel[compScheme];
|
||||
channel = setChannelFlags(channel, suffix);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_BITOFFSET] =
|
||||
(compSecondChannelOffset[compScheme] << KHR_DF_SAMPLESHIFT_BITOFFSET) |
|
||||
((compChannelBits[compScheme] - 1) << KHR_DF_SAMPLESHIFT_BITLENGTH) |
|
||||
(channel << KHR_DF_SAMPLESHIFT_CHANNELID);
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEPOSITION_ALL] = 0;
|
||||
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLELOWER] = lower.i;
|
||||
sample[KHR_DF_SAMPLEWORD_SAMPLEUPPER] = upper.i;
|
||||
}
|
||||
return DFD;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for a depth-stencil format.
|
||||
*
|
||||
* @param depthBits The numeber of bits in the depth channel.
|
||||
* @param stencilBits The numeber of bits in the stencil channel.
|
||||
* @param sizeBytes The total byte size of the texel.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDDepthStencil(int depthBits,
|
||||
int stencilBits,
|
||||
int sizeBytes)
|
||||
{
|
||||
/* N.B. Little-endian is assumed. */
|
||||
uint32_t *DFD = 0;
|
||||
DFD = writeHeader((depthBits > 0) + (stencilBits > 0),
|
||||
sizeBytes, s_UNORM, i_NON_COLOR);
|
||||
|
||||
/* Handle the special case of D24_UNORM_S8_UINT where the order of the
|
||||
channels is flipped by putting stencil in the LSBs. */
|
||||
if (depthBits == 24 && stencilBits == 8) {
|
||||
writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_STENCIL,
|
||||
8, 0,
|
||||
1, 1, s_UINT);
|
||||
writeSample(DFD, 1, KHR_DF_CHANNEL_RGBSDA_DEPTH,
|
||||
24, 8,
|
||||
1, 1, s_UNORM);
|
||||
return DFD;
|
||||
}
|
||||
|
||||
if (depthBits == 32) {
|
||||
writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_DEPTH,
|
||||
32, 0,
|
||||
1, 1, s_SFLOAT);
|
||||
} else if (depthBits > 0) {
|
||||
writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_DEPTH,
|
||||
depthBits, 0,
|
||||
1, 1, s_UNORM);
|
||||
}
|
||||
if (stencilBits > 0) {
|
||||
if (depthBits > 0) {
|
||||
writeSample(DFD, 1, KHR_DF_CHANNEL_RGBSDA_STENCIL,
|
||||
stencilBits, depthBits,
|
||||
1, 1, s_UINT);
|
||||
} else {
|
||||
writeSample(DFD, 0, KHR_DF_CHANNEL_RGBSDA_STENCIL,
|
||||
stencilBits, 0,
|
||||
1, 1, s_UINT);
|
||||
}
|
||||
}
|
||||
return DFD;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a Data Format Descriptor for an alpha-only format.
|
||||
*
|
||||
* @param bigEndian Set to 1 for big-endian byte ordering and
|
||||
0 for little-endian byte ordering.
|
||||
* @param bytes The number of bytes per channel.
|
||||
* @param suffix Indicates the format suffix for the type.
|
||||
*
|
||||
* @return A data format descriptor in malloc'd data. The caller is responsible
|
||||
* for freeing the descriptor.
|
||||
**/
|
||||
uint32_t *createDFDAlpha(int bigEndian, int bytes,
|
||||
enum VkSuffix suffix) {
|
||||
uint32_t *DFD;
|
||||
int channel = 3; /* alpha channel */
|
||||
if (bigEndian) {
|
||||
int channelByte;
|
||||
/* Number of samples = number of channels * bytes per channel */
|
||||
DFD = writeHeader(bytes, bytes, suffix, i_COLOR);
|
||||
/* Loop over the bytes that constitute a channel */
|
||||
for (channelByte = 0; channelByte < bytes; ++channelByte) {
|
||||
writeSample(DFD, channelByte, channel,
|
||||
8, 8 * (bytes - channelByte - 1),
|
||||
channelByte == bytes-1, channelByte == 0, suffix);
|
||||
}
|
||||
} else { /* Little-endian */
|
||||
/* One sample per channel */
|
||||
DFD = writeHeader(1, bytes, suffix, i_COLOR);
|
||||
writeSample(DFD, 0, channel,
|
||||
8 * bytes, 0,
|
||||
1, 1, suffix);
|
||||
}
|
||||
return DFD;
|
||||
}
|
236
thirdparty/libktx/external/dfdutils/dfd.h
vendored
Normal file
236
thirdparty/libktx/external/dfdutils/dfd.h
vendored
Normal file
@@ -0,0 +1,236 @@
|
||||
/* -*- tab-width: 4; -*- */
|
||||
/* vi: set sw=2 ts=4 expandtab: */
|
||||
|
||||
/* Copyright 2019-2020 The Khronos Group Inc.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Header file defining the data format descriptor utilities API.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Author: Andrew Garrard
|
||||
*/
|
||||
|
||||
#ifndef _DFD_H_
|
||||
#define _DFD_H_
|
||||
|
||||
#include <KHR/khr_df.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** Qualifier suffix to the format, in Vulkan terms. */
|
||||
enum VkSuffix {
|
||||
s_UNORM, /*!< Unsigned normalized format. */
|
||||
s_SNORM, /*!< Signed normalized format. */
|
||||
s_USCALED, /*!< Unsigned scaled format. */
|
||||
s_SSCALED, /*!< Signed scaled format. */
|
||||
s_UINT, /*!< Unsigned integer format. */
|
||||
s_SINT, /*!< Signed integer format. */
|
||||
s_SFLOAT, /*!< Signed float format. */
|
||||
s_UFLOAT, /*!< Unsigned float format. */
|
||||
s_SRGB, /*!< sRGB normalized format. */
|
||||
s_SFIXED5 /*!< 2's complement fixed-point; 5 fractional bits. */
|
||||
};
|
||||
|
||||
/** Compression scheme, in Vulkan terms. */
|
||||
enum VkCompScheme {
|
||||
c_BC1_RGB, /*!< BC1, aka DXT1, no alpha. */
|
||||
c_BC1_RGBA, /*!< BC1, aka DXT1, punch-through alpha. */
|
||||
c_BC2, /*!< BC2, aka DXT2 and DXT3. */
|
||||
c_BC3, /*!< BC3, aka DXT4 and DXT5. */
|
||||
c_BC4, /*!< BC4. */
|
||||
c_BC5, /*!< BC5. */
|
||||
c_BC6H, /*!< BC6h HDR format. */
|
||||
c_BC7, /*!< BC7. */
|
||||
c_ETC2_R8G8B8, /*!< ETC2 no alpha. */
|
||||
c_ETC2_R8G8B8A1, /*!< ETC2 punch-through alpha. */
|
||||
c_ETC2_R8G8B8A8, /*!< ETC2 independent alpha. */
|
||||
c_EAC_R11, /*!< R11 ETC2 single-channel. */
|
||||
c_EAC_R11G11, /*!< R11G11 ETC2 dual-channel. */
|
||||
c_ASTC, /*!< ASTC. */
|
||||
c_ETC1S, /*!< ETC1S. */
|
||||
c_PVRTC, /*!< PVRTC(1). */
|
||||
c_PVRTC2 /*!< PVRTC2. */
|
||||
};
|
||||
|
||||
typedef unsigned int uint32_t;
|
||||
|
||||
#if !defined(LIBKTX)
|
||||
#include <vulkan/vulkan_core.h>
|
||||
#else
|
||||
#include "../../lib/vkformat_enum.h"
|
||||
#endif
|
||||
|
||||
uint32_t* vk2dfd(enum VkFormat format);
|
||||
enum VkFormat dfd2vk(uint32_t* dfd);
|
||||
|
||||
/* Create a Data Format Descriptor for an unpacked format. */
|
||||
uint32_t *createDFDUnpacked(int bigEndian, int numChannels, int bytes,
|
||||
int redBlueSwap, enum VkSuffix suffix);
|
||||
|
||||
/* Create a Data Format Descriptor for a packed padded format. */
|
||||
uint32_t *createDFDPackedShifted(int bigEndian, int numChannels,
|
||||
int bits[], int shiftBits[],
|
||||
int channels[], enum VkSuffix suffix);
|
||||
|
||||
/* Create a Data Format Descriptor for a packed format. */
|
||||
uint32_t *createDFDPacked(int bigEndian, int numChannels,
|
||||
int bits[], int channels[],
|
||||
enum VkSuffix suffix);
|
||||
|
||||
/* Create a Data Format Descriptor for a 4:2:2 format. */
|
||||
uint32_t *createDFD422(int bigEndian, int numChannels,
|
||||
int bits[], int shiftBits[], int channels[],
|
||||
int position_xs[], int position_ys[],
|
||||
enum VkSuffix suffix);
|
||||
|
||||
/* Create a Data Format Descriptor for a compressed format. */
|
||||
uint32_t *createDFDCompressed(enum VkCompScheme compScheme,
|
||||
int bwidth, int bheight, int bdepth,
|
||||
enum VkSuffix suffix);
|
||||
|
||||
/* Create a Data Format Descriptor for a depth/stencil format. */
|
||||
uint32_t *createDFDDepthStencil(int depthBits,
|
||||
int stencilBits,
|
||||
int sizeBytes);
|
||||
|
||||
/* Create a Data Format Descriptor for an alpha-only format */
|
||||
uint32_t *createDFDAlpha(int bigEndian, int bytes,
|
||||
enum VkSuffix suffix);
|
||||
|
||||
/** @brief Result of interpreting the data format descriptor. */
|
||||
enum InterpretDFDResult {
|
||||
i_LITTLE_ENDIAN_FORMAT_BIT = 0, /*!< Confirmed little-endian (default for 8bpc). */
|
||||
i_BIG_ENDIAN_FORMAT_BIT = 1u << 0u, /*!< Confirmed big-endian. */
|
||||
i_PACKED_FORMAT_BIT = 1u << 1u, /*!< Packed format. */
|
||||
i_SRGB_FORMAT_BIT = 1u << 2u, /*!< sRGB transfer function. */
|
||||
i_NORMALIZED_FORMAT_BIT = 1u << 3u, /*!< Normalized (UNORM or SNORM). */
|
||||
i_SIGNED_FORMAT_BIT = 1u << 4u, /*!< Format is signed. */
|
||||
i_FIXED_FORMAT_BIT = 1u << 5u, /*!< Format is a fixed-point representation. */
|
||||
i_FLOAT_FORMAT_BIT = 1u << 6u, /*!< Format is floating point. */
|
||||
i_COMPRESSED_FORMAT_BIT = 1u << 7u, /*!< Format is block compressed (422). */
|
||||
i_YUVSDA_FORMAT_BIT = 1u << 8u, /*!< Color model is YUVSDA. */
|
||||
i_UNSUPPORTED_ERROR_BIT = 1u << 9u, /*!< Format not successfully interpreted. */
|
||||
/** "NONTRIVIAL_ENDIANNESS" means not big-endian, not little-endian
|
||||
* (a channel has bits that are not consecutive in either order). **/
|
||||
i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS = i_UNSUPPORTED_ERROR_BIT,
|
||||
/** "MULTIPLE_SAMPLE_LOCATIONS" is an error because only single-sample
|
||||
* texel blocks (with coordinates 0,0,0,0 for all samples) are supported. **/
|
||||
i_UNSUPPORTED_MULTIPLE_SAMPLE_LOCATIONS = i_UNSUPPORTED_ERROR_BIT + 1,
|
||||
/** "MULTIPLE_PLANES" is an error because only contiguous data is supported. */
|
||||
i_UNSUPPORTED_MULTIPLE_PLANES = i_UNSUPPORTED_ERROR_BIT + 2,
|
||||
/** Only channels R, G, B and A are supported. */
|
||||
i_UNSUPPORTED_CHANNEL_TYPES = i_UNSUPPORTED_ERROR_BIT + 3,
|
||||
/** Only channels with the same flags are supported
|
||||
* (e.g. we don't support float red with integer green). */
|
||||
i_UNSUPPORTED_MIXED_CHANNELS = i_UNSUPPORTED_ERROR_BIT + 4,
|
||||
/** Only 2x1 block is supported for YUVSDA model. */
|
||||
i_UNSUPPORTED_BLOCK_DIMENSIONS = i_UNSUPPORTED_ERROR_BIT + 5,
|
||||
};
|
||||
|
||||
/** @brief Interpretation of a channel from the data format descriptor. */
|
||||
typedef struct _InterpretedDFDChannel {
|
||||
uint32_t offset; /*!< Offset in bits for packed, bytes for unpacked. */
|
||||
uint32_t size; /*!< Size in bits for packed, bytes for unpacked. */
|
||||
} InterpretedDFDChannel;
|
||||
|
||||
/* Interpret a Data Format Descriptor. */
|
||||
enum InterpretDFDResult interpretDFD(const uint32_t *DFD,
|
||||
InterpretedDFDChannel *R,
|
||||
InterpretedDFDChannel *G,
|
||||
InterpretedDFDChannel *B,
|
||||
InterpretedDFDChannel *A,
|
||||
uint32_t *wordBytes);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringVendorID(khr_df_vendorid_e value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringDescriptorType(khr_df_khr_descriptortype_e value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringVersionNumber(khr_df_versionnumber_e value);
|
||||
|
||||
/* Returns the string representation of a bit in a khr_df_flags_e.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringFlagsBit(uint32_t bit_index, bool bit_value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringTransferFunction(khr_df_transfer_e value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringColorPrimaries(khr_df_primaries_e value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringColorModel(khr_df_model_e value);
|
||||
|
||||
/* Returns the string representation of a bit in a khr_df_sample_datatype_qualifiers_e.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringSampleDatatypeQualifiersBit(uint32_t bit_index, bool bit_value);
|
||||
|
||||
/* Returns the string representation.
|
||||
* If there is no direct match or the value is invalid returns NULL */
|
||||
const char* dfdToStringChannelId(khr_df_model_e model, khr_df_model_channels_e value);
|
||||
|
||||
/* Print a human-readable interpretation of a data format descriptor. */
|
||||
void printDFD(uint32_t *DFD, uint32_t dataSize);
|
||||
|
||||
/* Print a JSON interpretation of a data format descriptor. */
|
||||
void printDFDJSON(uint32_t *DFD, uint32_t dataSize, uint32_t base_indent, uint32_t indent_width, bool minified);
|
||||
|
||||
/* Get the number of components & component size from a DFD for an
|
||||
* unpacked format.
|
||||
*/
|
||||
void getDFDComponentInfoUnpacked(const uint32_t* DFD, uint32_t* numComponents,
|
||||
uint32_t* componentByteLength);
|
||||
|
||||
/* Return the number of components described by a DFD. */
|
||||
uint32_t getDFDNumComponents(const uint32_t* DFD);
|
||||
|
||||
/* Reconstruct and update the bytesPlane[0-4] fields of an unsized DFD to what
|
||||
* they were before supercompression.
|
||||
*/
|
||||
void reconstructDFDBytesPlanesFromSamples(uint32_t* DFD);
|
||||
/* Deprecated. For backward compatibility. */
|
||||
uint32_t reconstructDFDBytesPlane0FromSamples(const uint32_t* DFD);
|
||||
/* Deprecated. For backward compatibility. */
|
||||
void recreateBytesPlane0FromSampleInfo(const uint32_t* DFD,
|
||||
uint32_t* bytesPlane0);
|
||||
|
||||
/** @brief Colourspace primaries information.
|
||||
*
|
||||
* Structure to store the 1931 CIE x,y chromaticities of the red, green, and blue
|
||||
* display primaries and the reference white point of a colourspace.
|
||||
*/
|
||||
typedef struct _Primaries {
|
||||
float Rx; /*!< Red x. */
|
||||
float Ry; /*!< Red y. */
|
||||
float Gx; /*!< Green x. */
|
||||
float Gy; /*!< Green y. */
|
||||
float Bx; /*!< Blue x. */
|
||||
float By; /*!< Blue y. */
|
||||
float Wx; /*!< White x. */
|
||||
float Wy; /*!< White y. */
|
||||
} Primaries;
|
||||
|
||||
khr_df_primaries_e findMapping(const Primaries *p, float latitude);
|
||||
bool getPrimaries(khr_df_primaries_e primaries, Primaries *p);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _DFD_H_ */
|
663
thirdparty/libktx/external/dfdutils/dfd2vk.inl
vendored
Normal file
663
thirdparty/libktx/external/dfdutils/dfd2vk.inl
vendored
Normal file
@@ -0,0 +1,663 @@
|
||||
/* Copyright 2019-2020 The Khronos Group Inc. */
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/***************************** Do not edit. *****************************
|
||||
Automatically generated by makedfd2vk.pl.
|
||||
*************************************************************************/
|
||||
if (KHR_DFDVAL(dfd + 1, MODEL) == KHR_DF_MODEL_RGBSDA || KHR_DFDVAL(dfd + 1, MODEL) == KHR_DF_MODEL_YUVSDA) {
|
||||
enum InterpretDFDResult r;
|
||||
InterpretedDFDChannel R = {0,0};
|
||||
InterpretedDFDChannel G = {0,0};
|
||||
InterpretedDFDChannel B = {0,0};
|
||||
InterpretedDFDChannel A = {0,0};
|
||||
/* interpretDFD channel overloadings for YUVSDA formats. These are
|
||||
* different from the mapping used by Vulkan. */
|
||||
#define Y1 R
|
||||
#define Y2 A
|
||||
#define CB G
|
||||
#define U G
|
||||
#define CR B
|
||||
#define V B
|
||||
uint32_t wordBytes;
|
||||
|
||||
/* Special case exponent format */
|
||||
if (KHR_DFDSAMPLECOUNT(dfd + 1) == 6 &&
|
||||
((KHR_DFDSVAL((dfd + 1), 1, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_EXPONENT) > 0)) {
|
||||
/* The only format we expect to be encoded like this. */
|
||||
return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
|
||||
}
|
||||
|
||||
/* Special case depth formats (assumed little-endian) */
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, CHANNELID) == KHR_DF_CHANNEL_RGBSDA_DEPTH) {
|
||||
if (KHR_DFDSAMPLECOUNT((dfd + 1)) == 1) {
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, BITLENGTH) == 16-1) return VK_FORMAT_D16_UNORM;
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, BITLENGTH) == 24-1) return VK_FORMAT_X8_D24_UNORM_PACK32;
|
||||
return VK_FORMAT_D32_SFLOAT;
|
||||
} else {
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, BITLENGTH) == 16-1) return VK_FORMAT_D16_UNORM_S8_UINT;
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, BITLENGTH) == 24-1) return VK_FORMAT_D24_UNORM_S8_UINT;
|
||||
return VK_FORMAT_D32_SFLOAT_S8_UINT;
|
||||
}
|
||||
}
|
||||
if (KHR_DFDSVAL((dfd + 1), 0, CHANNELID) == KHR_DF_CHANNEL_RGBSDA_STENCIL) {
|
||||
if (KHR_DFDSAMPLECOUNT((dfd + 1)) == 1) {
|
||||
return VK_FORMAT_S8_UINT;
|
||||
} else {
|
||||
// The KTX 2.0 specification defines D24_UNORM_S8_UINT with S8 in the LSBs
|
||||
return VK_FORMAT_D24_UNORM_S8_UINT;
|
||||
}
|
||||
}
|
||||
|
||||
r = interpretDFD(dfd, &R, &G, &B, &A, &wordBytes);
|
||||
|
||||
if (r & i_UNSUPPORTED_ERROR_BIT) return VK_FORMAT_UNDEFINED;
|
||||
|
||||
if (r & i_PACKED_FORMAT_BIT) {
|
||||
if (wordBytes == 1) return VK_FORMAT_R4G4_UNORM_PACK8;
|
||||
else if (wordBytes == 2) { /* PACK16 */
|
||||
if (A.size == 4) {
|
||||
if (R.offset == 12) return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
|
||||
else if (B.offset == 12) return VK_FORMAT_B4G4R4A4_UNORM_PACK16;
|
||||
else if (A.offset == 12) {
|
||||
if (R.offset == 8) return VK_FORMAT_A4R4G4B4_UNORM_PACK16;
|
||||
else return VK_FORMAT_A4B4G4R4_UNORM_PACK16;
|
||||
}
|
||||
} else if (G.size == 0 && B.size == 0 && A.size == 0) { /* One channel */
|
||||
if (R.size == 10)
|
||||
return VK_FORMAT_R10X6_UNORM_PACK16;
|
||||
else if (R.size ==12)
|
||||
return VK_FORMAT_R12X4_UNORM_PACK16;
|
||||
} else if (A.size == 0) { /* Three channels */
|
||||
if (B.offset == 0) return VK_FORMAT_R5G6B5_UNORM_PACK16;
|
||||
else return VK_FORMAT_B5G6R5_UNORM_PACK16;
|
||||
} else { /* Four channels, one-bit alpha */
|
||||
if (B.offset == 0) return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
|
||||
if (B.offset == 1) return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
|
||||
if (B.offset == 10) return VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR;
|
||||
return VK_FORMAT_B5G5R5A1_UNORM_PACK16;
|
||||
}
|
||||
} else if (wordBytes == 4) { /* PACK32 or 2PACK16 */
|
||||
if (A.size == 8) {
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_A8B8G8R8_SRGB_PACK32;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A8B8G8R8_SNORM_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A8B8G8R8_UINT_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A8B8G8R8_SINT_PACK32;
|
||||
} else if (A.size == 2 && B.offset == 0) {
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2R10G10B10_SNORM_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2R10G10B10_UINT_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2R10G10B10_SINT_PACK32;
|
||||
} else if (A.size == 2 && R.offset == 0) {
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2B10G10R10_UINT_PACK32;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_A2B10G10R10_SINT_PACK32;
|
||||
} else if (R.size == 11) {
|
||||
return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
|
||||
} else if (R.size == 10 && G.size == 10 && B.size == 0) {
|
||||
return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
|
||||
} else if (R.size == 12 && G.size == 12 && B.size == 0) {
|
||||
return VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
|
||||
}
|
||||
} else if (wordBytes == 8) { /* 4PACK16 */
|
||||
if (r & i_YUVSDA_FORMAT_BIT) {
|
||||
/* In Vulkan G = Y, R = Cr, B = Cb. */
|
||||
if (Y1.size == 10 && Y1.offset == 6 && Y2.size == 10 && Y2.offset == 38)
|
||||
return VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
|
||||
if (Y1.size == 10 && Y1.offset == 22 && Y2.size == 10 && Y2.offset == 54)
|
||||
return VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
|
||||
if (Y1.size == 12 && Y1.offset == 4 && Y2.size == 12 && Y2.offset == 36)
|
||||
return VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
|
||||
if (Y1.size == 12 && Y1.offset == 20 && Y2.size == 12 && Y2.offset == 52)
|
||||
return VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
|
||||
} else {
|
||||
if (R.size == 10)
|
||||
return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
|
||||
else if (R.size == 12)
|
||||
return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
|
||||
}
|
||||
}
|
||||
} else { /* Not a packed format */
|
||||
if (r & i_YUVSDA_FORMAT_BIT) {
|
||||
/* In Vulkan G = Y, R = Cr, B = Cb. */
|
||||
if (Y1.size == 1 && Y1.offset == 0 && Y2.size == 1 && Y2.offset == 2)
|
||||
return VK_FORMAT_G8B8G8R8_422_UNORM;
|
||||
else if (Y1.size == 1 && Y1.offset == 1 && Y2.size == 1 && Y2.offset == 3)
|
||||
return VK_FORMAT_B8G8R8G8_422_UNORM;
|
||||
else if (Y1.size == 2 && Y1.offset == 0 && Y2.size == 2 && Y2.offset == 4)
|
||||
return VK_FORMAT_G16B16G16R16_422_UNORM;
|
||||
else if (Y1.size == 2 && Y1.offset == 2 && Y2.size == 2 && Y2.offset == 6)
|
||||
return VK_FORMAT_B16G16R16G16_422_UNORM;
|
||||
else
|
||||
return VK_FORMAT_UNDEFINED; // Until support added.
|
||||
} else { /* Not YUV */
|
||||
if (wordBytes == 1) {
|
||||
if (A.size == 1 && R.size == 0 && G.size == 0 && B.size == 0 && (r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) {
|
||||
return VK_FORMAT_A8_UNORM_KHR;
|
||||
}
|
||||
if (A.size > 0) { /* 4 channels */
|
||||
if (R.offset == 0) { /* RGBA */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_R8G8B8A8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8A8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8A8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8A8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8A8_SINT;
|
||||
} else { /* BGRA */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_B8G8R8A8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8A8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8A8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8A8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8A8_SINT;
|
||||
}
|
||||
} else if (B.size > 0) { /* 3 channels */
|
||||
if (R.offset == 0) { /* RGB */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_R8G8B8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8B8_SINT;
|
||||
} else { /* BGR */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_B8G8R8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_B8G8R8_SINT;
|
||||
}
|
||||
} else if (G.size > 0) { /* 2 channels */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_R8G8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8G8_SINT;
|
||||
} else { /* 1 channel */
|
||||
if ((r & i_SRGB_FORMAT_BIT)) return VK_FORMAT_R8_SRGB;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R8_SINT;
|
||||
}
|
||||
} else if (wordBytes == 2) {
|
||||
if ((r & i_FIXED_FORMAT_BIT) && R.size == 2 && G.size == 2) return VK_FORMAT_R16G16_SFIXED5_NV;
|
||||
if (A.size > 0) { /* 4 channels */
|
||||
if (R.offset == 0) { /* RGBA */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R16G16B16A16_SFLOAT;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16A16_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16A16_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16A16_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16A16_SINT;
|
||||
} else { /* BGRA */
|
||||
}
|
||||
} else if (B.size > 0) { /* 3 channels */
|
||||
if (R.offset == 0) { /* RGB */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R16G16B16_SFLOAT;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16B16_SINT;
|
||||
} else { /* BGR */
|
||||
}
|
||||
} else if (G.size > 0) { /* 2 channels */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R16G16_SFLOAT;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16G16_SINT;
|
||||
} else { /* 1 channel */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R16_SFLOAT;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16_UNORM;
|
||||
if ((r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16_SNORM;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R16_SINT;
|
||||
}
|
||||
} else if (wordBytes == 4) {
|
||||
if (A.size > 0) { /* 4 channels */
|
||||
if (R.offset == 0) { /* RGBA */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R32G32B32A32_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32B32A32_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32B32A32_SINT;
|
||||
} else { /* BGRA */
|
||||
}
|
||||
} else if (B.size > 0) { /* 3 channels */
|
||||
if (R.offset == 0) { /* RGB */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R32G32B32_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32B32_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32B32_SINT;
|
||||
} else { /* BGR */
|
||||
}
|
||||
} else if (G.size > 0) { /* 2 channels */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R32G32_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32G32_SINT;
|
||||
} else { /* 1 channel */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R32_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R32_SINT;
|
||||
}
|
||||
} else if (wordBytes == 8) {
|
||||
if (A.size > 0) { /* 4 channels */
|
||||
if (R.offset == 0) { /* RGBA */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R64G64B64A64_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64B64A64_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64B64A64_SINT;
|
||||
} else { /* BGRA */
|
||||
}
|
||||
} else if (B.size > 0) { /* 3 channels */
|
||||
if (R.offset == 0) { /* RGB */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R64G64B64_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64B64_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64B64_SINT;
|
||||
} else { /* BGR */
|
||||
}
|
||||
} else if (G.size > 0) { /* 2 channels */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R64G64_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64G64_SINT;
|
||||
} else { /* 1 channel */
|
||||
if ((r & i_FLOAT_FORMAT_BIT)) return VK_FORMAT_R64_SFLOAT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && !(r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64_UINT;
|
||||
if (!(r & i_NORMALIZED_FORMAT_BIT) && (r & i_SIGNED_FORMAT_BIT)) return VK_FORMAT_R64_SINT;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (KHR_DFDVAL((dfd + 1), MODEL) >= 128) {
|
||||
const uint32_t *bdb = dfd + 1;
|
||||
switch (KHR_DFDVAL(bdb, MODEL)) {
|
||||
case KHR_DF_MODEL_BC1A:
|
||||
if (KHR_DFDSVAL(bdb, 0, CHANNELID) == KHR_DF_CHANNEL_BC1A_COLOR) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC1_RGB_SRGB_BLOCK;
|
||||
}
|
||||
} else {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
|
||||
}
|
||||
}
|
||||
case KHR_DF_MODEL_BC2:
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_BC2_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC2_SRGB_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_BC3:
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_BC3_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC3_SRGB_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_BC4:
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED)) {
|
||||
return VK_FORMAT_BC4_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC4_SNORM_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_BC5:
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED)) {
|
||||
return VK_FORMAT_BC5_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC5_SNORM_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_BC6H:
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED)) {
|
||||
return VK_FORMAT_BC6H_UFLOAT_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC6H_SFLOAT_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_BC7:
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_BC7_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_BC7_SRGB_BLOCK;
|
||||
}
|
||||
case KHR_DF_MODEL_ETC2:
|
||||
if (KHR_DFDSVAL(bdb, 0, CHANNELID) == KHR_DF_CHANNEL_ETC2_COLOR) {
|
||||
if (KHR_DFDVAL(bdb, DESCRIPTORBLOCKSIZE) == 40) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
|
||||
}
|
||||
} else {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
|
||||
}
|
||||
}
|
||||
} else if (KHR_DFDSVAL(bdb, 0, CHANNELID) == KHR_DF_CHANNEL_ETC2_ALPHA) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
|
||||
}
|
||||
} else if (KHR_DFDVAL(bdb, DESCRIPTORBLOCKSIZE) == 40) {
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED)) {
|
||||
return VK_FORMAT_EAC_R11_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_EAC_R11_SNORM_BLOCK;
|
||||
}
|
||||
} else {
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED)) {
|
||||
return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
|
||||
}
|
||||
}
|
||||
case KHR_DF_MODEL_ASTC:
|
||||
if (!(KHR_DFDSVAL(bdb, 0, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT)) {
|
||||
if (KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 0) {
|
||||
if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 7)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 7)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 9)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 11) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 9)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 11) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 11)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT;
|
||||
}
|
||||
}
|
||||
if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT;
|
||||
}
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 5)) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) != KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT;
|
||||
} else {
|
||||
return VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 0) {
|
||||
if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3)) {
|
||||
return VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3)) {
|
||||
return VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
return VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
return VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
return VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
return VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
return VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 7) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 7)) {
|
||||
return VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4)) {
|
||||
return VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5)) {
|
||||
return VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 7)) {
|
||||
return VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 9) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 9)) {
|
||||
return VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 11) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 9)) {
|
||||
return VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 11) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 11)) {
|
||||
return VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT;
|
||||
}
|
||||
} else {
|
||||
if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
return VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
return VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 2) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
return VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 2)) {
|
||||
return VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
return VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 3) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
return VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 3)) {
|
||||
return VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
return VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 4) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
return VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 4)) {
|
||||
return VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT;
|
||||
} else if ((KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION1) == 5) &&
|
||||
(KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION2) == 5)) {
|
||||
return VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case KHR_DF_MODEL_PVRTC:
|
||||
if (KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) == KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG;
|
||||
} else {
|
||||
return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
}
|
||||
} else {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) == KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG;
|
||||
} else {
|
||||
return VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
|
||||
}
|
||||
}
|
||||
case KHR_DF_MODEL_PVRTC2:
|
||||
if (KHR_DFDVAL(bdb, TEXELBLOCKDIMENSION0) == 3) {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) == KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG;
|
||||
} else {
|
||||
return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG;
|
||||
}
|
||||
} else {
|
||||
if (KHR_DFDVAL(bdb, TRANSFER) == KHR_DF_TRANSFER_SRGB) {
|
||||
return VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG;
|
||||
} else {
|
||||
return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG;
|
||||
}
|
||||
}
|
||||
default:
|
||||
;
|
||||
}
|
||||
}
|
||||
return VK_FORMAT_UNDEFINED; /* Drop-through for unmatched formats. */
|
460
thirdparty/libktx/external/dfdutils/interpretdfd.c
vendored
Normal file
460
thirdparty/libktx/external/dfdutils/interpretdfd.c
vendored
Normal file
@@ -0,0 +1,460 @@
|
||||
/* -*- tab-width: 4; -*- */
|
||||
/* vi: set sw=2 ts=4 expandtab: */
|
||||
|
||||
/* Copyright 2019-2020 The Khronos Group Inc.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Utility for interpreting a data format descriptor.
|
||||
* @author Andrew Garrard
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <KHR/khr_df.h>
|
||||
#include "dfd.h"
|
||||
|
||||
static uint32_t bit_ceil(uint32_t x) {
|
||||
x -= 1;
|
||||
for (uint32_t i = 0; i < sizeof(x) * 8; ++i)
|
||||
if (1u << i > x)
|
||||
return 1u << i;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Interpret a Data Format Descriptor for a simple format.
|
||||
*
|
||||
* Handles "simple" cases that can be translated to things a GPU can access.
|
||||
* For simplicity, it ignores the compressed formats, which are generally a
|
||||
* single sample (and I believe are all defined to be little-endian in their
|
||||
* in-memory layout, even if some documentation confuses this). Focuses on
|
||||
* the layout and ignores sRGB except for reporting if that is the transfer
|
||||
* function by way of a bit in the returned value.
|
||||
*
|
||||
* @param[in] DFD Pointer to a Data Format Descriptor to interpret,
|
||||
* described as 32-bit words in native endianness.
|
||||
* Note that this is the whole descriptor, not just
|
||||
* the basic descriptor block.
|
||||
* @param R[in,out] Pointer to struct to receive information about the decoded
|
||||
* red channel, the Y channel, if YUV, or the depth channel,
|
||||
* if any.
|
||||
* @param G[in,out] Pointer to struct to receive information about the decoded
|
||||
* green channel, the U (Cb) channel, if YUV, or the stencil
|
||||
* channel, if any.
|
||||
* @param B[in,out] Pointer to struct to receive information about the decoded
|
||||
* blue channel, if any or the V (Cr) channel, if YUV.
|
||||
* @param A[in,out] Pointer to struct to receive information about the decoded
|
||||
* alpha channel, if any or the second Y channel, if YUV and
|
||||
* any.
|
||||
* @param wordBytes[in,out] Pointer to a uint32_t to receive the byte size of
|
||||
* the channels (unpacked) or total size (packed).
|
||||
*
|
||||
* @return An enumerant describing the decoded value,
|
||||
* or an error code in case of failure.
|
||||
*
|
||||
* The mapping of YUV channels to the parameter names used here is based on
|
||||
* the channel ids in @c khr_df.h and is different from the convention used
|
||||
* in format names in the Vulkan specification where G == Y, R = Cr and B = Cb.
|
||||
**/
|
||||
enum InterpretDFDResult interpretDFD(const uint32_t *DFD,
|
||||
InterpretedDFDChannel *R,
|
||||
InterpretedDFDChannel *G,
|
||||
InterpretedDFDChannel *B,
|
||||
InterpretedDFDChannel *A,
|
||||
uint32_t *wordBytes)
|
||||
{
|
||||
/* DFD points to the whole descriptor, not the basic descriptor block. */
|
||||
/* Make everything else relative to the basic descriptor block. */
|
||||
const uint32_t *BDFDB = DFD+1;
|
||||
|
||||
uint32_t numSamples = KHR_DFDSAMPLECOUNT(BDFDB);
|
||||
if (numSamples == 0)
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
|
||||
int determinedEndianness = 0;
|
||||
enum InterpretDFDResult result = 0; /* Build this up incrementally. */
|
||||
|
||||
bool isDepthStencil = false;
|
||||
|
||||
/* Clear these so following code doesn't get confused. */
|
||||
R->offset = R->size = 0;
|
||||
G->offset = G->size = 0;
|
||||
B->offset = B->size = 0;
|
||||
A->offset = A->size = 0;
|
||||
|
||||
/* First rule out the multiple planes case (trivially) */
|
||||
/* - that is, we check that only bytesPlane0 is non-zero. */
|
||||
/* This means we don't handle multi-plane YUV, even if the API could. */
|
||||
/* (We rely on KHR_DF_WORD_BYTESPLANE0..3 being the same and */
|
||||
/* KHR_DF_WORD_BYTESPLANE4..7 being the same as a short cut.) */
|
||||
if ((BDFDB[KHR_DF_WORD_BYTESPLANE0] & ~KHR_DF_MASK_BYTESPLANE0)
|
||||
|| BDFDB[KHR_DF_WORD_BYTESPLANE4]) return i_UNSUPPORTED_MULTIPLE_PLANES;
|
||||
|
||||
/* If this is a packed format, we work out our offsets differently. */
|
||||
/* We assume a packed format has channels that aren't byte-aligned. */
|
||||
/* If we have a format in which every channel is byte-aligned *and* packed, */
|
||||
/* we have the RGBA/ABGR ambiguity; we *probably* don't want the packed */
|
||||
/* version in this case, and if hardware has to pack it and swizzle, */
|
||||
/* that's up to the hardware to special-case. */
|
||||
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
||||
uint32_t offset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET);
|
||||
uint32_t length = KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1;
|
||||
if ((offset & 0x7U) || ((offset + length) & 0x7U)) {
|
||||
result |= i_PACKED_FORMAT_BIT;
|
||||
/* Once we're packed, we're packed, no need to keep checking. */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check data types.
|
||||
bool hasSigned = false;
|
||||
bool hasFloat = false;
|
||||
bool hasNormalized = false;
|
||||
bool hasFixed = false;
|
||||
khr_df_model_e model = KHR_DFDVAL(BDFDB, MODEL);
|
||||
|
||||
// Note: We're ignoring 9995, which is weird and worth special-casing
|
||||
// rather than trying to generalise to all float formats.
|
||||
for (uint32_t i = 0; i < numSamples; ++i) {
|
||||
const bool isSigned = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED) != 0;
|
||||
const bool isFloat = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT) != 0;
|
||||
|
||||
// We define "unnormalized" as "sample_upper = 1" or "sample_upper = 1.0f".
|
||||
// We don't check whether any non-1 normalization value is correct
|
||||
// (i.e. set to the maximum bit value, and check min value) on
|
||||
// the assumption that we're looking at a format which *came* from
|
||||
// an API we can support.
|
||||
bool isFixed;
|
||||
bool isNormalized;
|
||||
if (isFloat) {
|
||||
isNormalized = *(float*) (void*) &BDFDB[KHR_DF_WORD_SAMPLESTART +
|
||||
KHR_DF_WORD_SAMPLEWORDS * i +
|
||||
KHR_DF_SAMPLEWORD_SAMPLEUPPER] != 1.0f;
|
||||
isFixed = false;
|
||||
} else {
|
||||
uint32_t sampleUpper = KHR_DFDSVAL(BDFDB, i, SAMPLEUPPER);
|
||||
uint32_t maxVal = 1U << KHR_DFDSVAL(BDFDB, i, BITLENGTH);
|
||||
if (!isSigned) maxVal <<= 1;
|
||||
maxVal--;
|
||||
isFixed = 1U < sampleUpper && sampleUpper < maxVal;
|
||||
isNormalized = !isFixed && sampleUpper != 1U;
|
||||
}
|
||||
hasSigned |= isSigned;
|
||||
hasFixed |= isFixed;
|
||||
hasFloat |= isFloat;
|
||||
// By our definition the normalizedness of a single bit channel (like in RGBA 5:5:5:1)
|
||||
// is ambiguous. Ignore these during normalized checks.
|
||||
if (KHR_DFDSVAL(BDFDB, i, BITLENGTH) > 0)
|
||||
hasNormalized |= isNormalized;
|
||||
}
|
||||
result |= hasSigned ? i_SIGNED_FORMAT_BIT : 0;
|
||||
result |= hasFloat ? i_FLOAT_FORMAT_BIT : 0;
|
||||
result |= hasNormalized ? i_NORMALIZED_FORMAT_BIT : 0;
|
||||
result |= hasFixed ? i_FIXED_FORMAT_BIT : 0;
|
||||
|
||||
// Checks based on color model
|
||||
if (model == KHR_DF_MODEL_YUVSDA) {
|
||||
result |= i_NORMALIZED_FORMAT_BIT;
|
||||
result |= i_COMPRESSED_FORMAT_BIT;
|
||||
result |= i_YUVSDA_FORMAT_BIT;
|
||||
|
||||
for (uint32_t i = 0; i < numSamples; ++i) {
|
||||
switch (KHR_DFDSVAL(BDFDB, i, CHANNELID)) {
|
||||
case KHR_DF_CHANNEL_YUVSDA_Y:
|
||||
case KHR_DF_CHANNEL_YUVSDA_U:
|
||||
case KHR_DF_CHANNEL_YUVSDA_V:
|
||||
case KHR_DF_CHANNEL_YUVSDA_A:
|
||||
break;
|
||||
case KHR_DF_CHANNEL_YUVSDA_DEPTH:
|
||||
case KHR_DF_CHANNEL_YUVSDA_STENCIL:
|
||||
isDepthStencil = true;
|
||||
break;
|
||||
default:
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
}
|
||||
|
||||
// Determine wordBytes
|
||||
uint32_t largestSampleSize = 0;
|
||||
for (uint32_t i = 0; i < numSamples; ++i) {
|
||||
uint32_t length = KHR_DFDSVAL(BDFDB, i, BITLENGTH) + 1;
|
||||
if (largestSampleSize < length)
|
||||
largestSampleSize = length;
|
||||
}
|
||||
*wordBytes = ((result & i_PACKED_FORMAT_BIT) ? 4 : 1) * bit_ceil(largestSampleSize) / 8;
|
||||
|
||||
} else if (KHR_DFDVAL(BDFDB, MODEL) == KHR_DF_MODEL_RGBSDA) {
|
||||
/* Check if transfer is sRGB. */
|
||||
if (KHR_DFDVAL(BDFDB, TRANSFER) == KHR_DF_TRANSFER_SRGB) result |= i_SRGB_FORMAT_BIT;
|
||||
|
||||
/* We only support samples at coordinate 0,0,0,0. */
|
||||
/* (We could confirm this from texel_block_dimensions in 1.2, but */
|
||||
/* the interpretation might change in later versions.) */
|
||||
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
||||
if (KHR_DFDSVAL(BDFDB, sampleCounter, SAMPLEPOSITION_ALL))
|
||||
return i_UNSUPPORTED_MULTIPLE_SAMPLE_LOCATIONS;
|
||||
}
|
||||
}
|
||||
|
||||
if (model == KHR_DF_MODEL_RGBSDA || model == KHR_DF_MODEL_YUVSDA) {
|
||||
/* The values of the DEPTH and STENCIL tokens are the same for */
|
||||
/* RGBSDA and YUVSDA. */
|
||||
/* For Depth/Stencil formats mixed channels are allowed */
|
||||
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
||||
switch (KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID)) {
|
||||
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
||||
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
||||
isDepthStencil = true;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check for mixed channels
|
||||
if (!isDepthStencil) {
|
||||
for (uint32_t i = 0; i < numSamples; ++i) {
|
||||
const bool isSigned = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_SIGNED) != 0;
|
||||
const bool isFloat = (KHR_DFDSVAL(BDFDB, i, QUALIFIERS) & KHR_DF_SAMPLE_DATATYPE_FLOAT) != 0;
|
||||
|
||||
if (isSigned != hasSigned)
|
||||
return i_UNSUPPORTED_MIXED_CHANNELS;
|
||||
if (isFloat != hasFloat)
|
||||
return i_UNSUPPORTED_MIXED_CHANNELS;
|
||||
|
||||
// Note: We don't check for inconsistent normalization, because
|
||||
// channels composed of multiple samples will have 0 in the
|
||||
// lower/upper range. Single bit channels are also ambiguous.
|
||||
// This heuristic should handle 64-bit integers, too.
|
||||
}
|
||||
}
|
||||
|
||||
/* This all relies on the channel id values for RGB being equal to */
|
||||
/* those for YUV. */
|
||||
|
||||
/* Remember: the canonical ordering of samples is to start with */
|
||||
/* the lowest bit of the channel/location which touches bit 0 of */
|
||||
/* the data, when the latter is concatenated in little-endian order, */
|
||||
/* and then progress until all the bits of that channel/location */
|
||||
/* have been processed. Multiple channels sharing the same source */
|
||||
/* bits are processed in channel ID order. (I should clarify this */
|
||||
/* for partially-shared data, but it doesn't really matter so long */
|
||||
/* as everything is consecutive, except to make things canonical.) */
|
||||
/* Note: For standard formats we could determine big/little-endianness */
|
||||
/* simply from whether the first sample starts in bit 0; technically */
|
||||
/* it's possible to have a format with unaligned channels wherein the */
|
||||
/* first channel starts at bit 0 and is one byte, yet other channels */
|
||||
/* take more bytes or aren't aligned (e.g. D24S8), but this should be */
|
||||
/* irrelevant for the formats that we support. */
|
||||
if ((result & i_PACKED_FORMAT_BIT)) {
|
||||
/* A packed format. */
|
||||
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
||||
uint32_t currentBitOffset = 0;
|
||||
uint32_t currentByteOffset = 0;
|
||||
uint32_t currentBitLength = 0;
|
||||
*wordBytes = (BDFDB[KHR_DF_WORD_BYTESPLANE0] & 0xFFU);
|
||||
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
||||
uint32_t sampleBitOffset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET);
|
||||
uint32_t sampleByteOffset = sampleBitOffset >> 3U;
|
||||
/* The sample bitLength field stores the bit length - 1. */
|
||||
uint32_t sampleBitLength = KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1;
|
||||
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID);
|
||||
InterpretedDFDChannel *sampleChannelPtr;
|
||||
switch (sampleChannel) {
|
||||
case KHR_DF_CHANNEL_RGBSDA_RED:
|
||||
sampleChannelPtr = R;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_GREEN:
|
||||
sampleChannelPtr = G;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_BLUE:
|
||||
sampleChannelPtr = B;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
||||
sampleChannelPtr = R;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
||||
sampleChannelPtr = G;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_ALPHA:
|
||||
sampleChannelPtr = A;
|
||||
break;
|
||||
default:
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
if (sampleChannel == currentChannel) {
|
||||
/* Continuation of the same channel. */
|
||||
/* Since a big (>32-bit) channel isn't "packed", */
|
||||
/* this should only happen in big-endian, or if */
|
||||
/* we have a wacky format that we won't support. */
|
||||
if (sampleByteOffset == currentByteOffset - 1U && /* One byte earlier */
|
||||
((currentBitOffset + currentBitLength) & 7U) == 0 && /* Already at the end of a byte */
|
||||
(sampleBitOffset & 7U) == 0) { /* Start at the beginning of the byte */
|
||||
/* All is good, continue big-endian. */
|
||||
/* N.B. We shouldn't be here if we decided we were little-endian, */
|
||||
/* so we don't bother to check that disagreement. */
|
||||
result |= i_BIG_ENDIAN_FORMAT_BIT;
|
||||
determinedEndianness = 1;
|
||||
} else {
|
||||
/* Oh dear. */
|
||||
/* We could be little-endian, but not with any standard format. */
|
||||
/* More likely we've got something weird that we can't support. */
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
/* Remember where we are. */
|
||||
currentBitOffset = sampleBitOffset;
|
||||
currentByteOffset = sampleByteOffset;
|
||||
currentBitLength = sampleBitLength;
|
||||
/* Accumulate the bit length. */
|
||||
sampleChannelPtr->size += sampleBitLength;
|
||||
} else {
|
||||
/* Everything is new. Hopefully. */
|
||||
currentChannel = sampleChannel;
|
||||
currentBitOffset = sampleBitOffset;
|
||||
currentByteOffset = sampleByteOffset;
|
||||
currentBitLength = sampleBitLength;
|
||||
if (sampleChannelPtr->size) {
|
||||
if (model == KHR_DF_MODEL_YUVSDA && sampleChannel == KHR_DF_CHANNEL_YUVSDA_Y) {
|
||||
if (sampleChannelPtr == R) {
|
||||
/* We've got another Y channel. Record details in A. */
|
||||
if (A->size == 0) {
|
||||
sampleChannelPtr = A;
|
||||
} else {
|
||||
/* Uh-oh, we've already got a second Y or an alpha channel. */
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Uh-oh, we've seen this channel before. */
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
}
|
||||
/* For now, record the bit offset in little-endian terms, */
|
||||
/* because we may not know to reverse it yet. */
|
||||
sampleChannelPtr->offset = sampleBitOffset;
|
||||
sampleChannelPtr->size = sampleBitLength;
|
||||
}
|
||||
}
|
||||
if ((result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
||||
/* Our bit offsets to bit 0 of each channel are in little-endian terms. */
|
||||
/* We need to do a byte swap to work out where they should be. */
|
||||
/* We assume, for sanity, that byte sizes are a power of two for this. */
|
||||
uint32_t offsetMask = (*wordBytes - 1U) << 3U;
|
||||
R->offset ^= offsetMask;
|
||||
G->offset ^= offsetMask;
|
||||
B->offset ^= offsetMask;
|
||||
A->offset ^= offsetMask;
|
||||
}
|
||||
} else {
|
||||
/* Not a packed format. */
|
||||
/* Everything is byte-aligned. */
|
||||
/* Question is whether there multiple samples per channel. */
|
||||
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
||||
uint32_t currentByteOffset = 0;
|
||||
uint32_t currentByteLength = 0;
|
||||
for (uint32_t sampleCounter = 0; sampleCounter < numSamples; ++sampleCounter) {
|
||||
uint32_t sampleByteOffset = KHR_DFDSVAL(BDFDB, sampleCounter, BITOFFSET) >> 3U;
|
||||
uint32_t sampleByteLength = (KHR_DFDSVAL(BDFDB, sampleCounter, BITLENGTH) + 1) >> 3U;
|
||||
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleCounter, CHANNELID);
|
||||
InterpretedDFDChannel *sampleChannelPtr;
|
||||
switch (sampleChannel) {
|
||||
case KHR_DF_CHANNEL_RGBSDA_RED:
|
||||
sampleChannelPtr = R;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_GREEN:
|
||||
sampleChannelPtr = G;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_BLUE:
|
||||
sampleChannelPtr = B;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_DEPTH:
|
||||
sampleChannelPtr = R;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_STENCIL:
|
||||
sampleChannelPtr = G;
|
||||
break;
|
||||
case KHR_DF_CHANNEL_RGBSDA_ALPHA:
|
||||
sampleChannelPtr = A;
|
||||
break;
|
||||
default:
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
if (sampleChannel == currentChannel) {
|
||||
/* Continuation of the same channel. */
|
||||
/* Either big-endian, or little-endian with a very large channel. */
|
||||
if (sampleByteOffset == currentByteOffset - 1) { /* One byte earlier */
|
||||
if (determinedEndianness && !(result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
/* All is good, continue big-endian. */
|
||||
result |= i_BIG_ENDIAN_FORMAT_BIT;
|
||||
determinedEndianness = 1;
|
||||
/* Update the start */
|
||||
sampleChannelPtr->offset = sampleByteOffset;
|
||||
} else if (sampleByteOffset == currentByteOffset + currentByteLength) {
|
||||
if (determinedEndianness && (result & i_BIG_ENDIAN_FORMAT_BIT)) {
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
/* All is good, continue little-endian. */
|
||||
determinedEndianness = 1;
|
||||
} else {
|
||||
/* Oh dear. */
|
||||
/* We could be little-endian, but not with any standard format. */
|
||||
/* More likely we've got something weird that we can't support. */
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
/* Remember where we are. */
|
||||
currentByteOffset = sampleByteOffset;
|
||||
currentByteLength = sampleByteLength;
|
||||
/* Accumulate the byte length. */
|
||||
sampleChannelPtr->size += sampleByteLength;
|
||||
/* Assume these are all the same. */
|
||||
*wordBytes = sampleChannelPtr->size;
|
||||
} else {
|
||||
/* Everything is new. Hopefully. */
|
||||
currentChannel = sampleChannel;
|
||||
currentByteOffset = sampleByteOffset;
|
||||
currentByteLength = sampleByteLength;
|
||||
if (sampleChannelPtr->size) {
|
||||
if (model == KHR_DF_MODEL_YUVSDA && sampleChannel == KHR_DF_CHANNEL_YUVSDA_Y) {
|
||||
if (sampleChannelPtr == R) {
|
||||
/* We've got another Y channel. Record details in A. */
|
||||
if (A->size == 0) {
|
||||
sampleChannelPtr = A;
|
||||
} else {
|
||||
/* Uh-oh, we've already got a second Y or an alpha channel. */
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Uh-oh, we've seen this channel before. */
|
||||
return i_UNSUPPORTED_NONTRIVIAL_ENDIANNESS;
|
||||
}
|
||||
}
|
||||
/* For now, record the byte offset in little-endian terms, */
|
||||
/* because we may not know to reverse it yet. */
|
||||
sampleChannelPtr->offset = sampleByteOffset;
|
||||
sampleChannelPtr->size = sampleByteLength;
|
||||
/* Assume these are all the same. */
|
||||
*wordBytes = sampleByteLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return i_UNSUPPORTED_CHANNEL_TYPES;
|
||||
}
|
||||
|
||||
if (isDepthStencil) {
|
||||
/* For Depth/Stencil formats wordBytes is determined by the required alignment of */
|
||||
/* the larger channel. */
|
||||
uint32_t largerSize = R->size > G->size ? R->size : G->size;
|
||||
*wordBytes = bit_ceil(largerSize);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
1050
thirdparty/libktx/external/dfdutils/printdfd.c
vendored
Normal file
1050
thirdparty/libktx/external/dfdutils/printdfd.c
vendored
Normal file
File diff suppressed because it is too large
Load Diff
215
thirdparty/libktx/external/dfdutils/queries.c
vendored
Normal file
215
thirdparty/libktx/external/dfdutils/queries.c
vendored
Normal file
@@ -0,0 +1,215 @@
|
||||
/* -*- tab-width: 4; -*- */
|
||||
/* vi: set sw=2 ts=4 expandtab: */
|
||||
|
||||
/* Copyright 2019-2020 The Khronos Group Inc.
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Utilities for querying info from a data format descriptor.
|
||||
* @author Mark Callow
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <KHR/khr_df.h>
|
||||
#include "dfd.h"
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Get the number and size of the image components from a DFD.
|
||||
*
|
||||
* This simplified function is for use only with the DFDs for unpacked
|
||||
* formats which means all components have the same size.
|
||||
*
|
||||
* @param DFD Pointer to a Data Format Descriptor to interpret,
|
||||
described as 32-bit words in native endianness.
|
||||
Note that this is the whole descriptor, not just
|
||||
the basic descriptor block.
|
||||
* @param numComponents pointer to a 32-bit word in which the number of
|
||||
components will be written.
|
||||
* @param componentByteLength pointer to a 32-bit word in which the size of
|
||||
a component in bytes will be written.
|
||||
*/
|
||||
void
|
||||
getDFDComponentInfoUnpacked(const uint32_t* DFD, uint32_t* numComponents,
|
||||
uint32_t* componentByteLength)
|
||||
{
|
||||
const uint32_t *BDFDB = DFD+1;
|
||||
uint32_t numSamples = KHR_DFDSAMPLECOUNT(BDFDB);
|
||||
uint32_t sampleNumber;
|
||||
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
||||
|
||||
/* This is specifically for unpacked formats which means the size of */
|
||||
/* each component is the same. */
|
||||
*numComponents = 0;
|
||||
for (sampleNumber = 0; sampleNumber < numSamples; ++sampleNumber) {
|
||||
uint32_t sampleByteLength = (KHR_DFDSVAL(BDFDB, sampleNumber, BITLENGTH) + 1) >> 3U;
|
||||
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleNumber, CHANNELID);
|
||||
|
||||
if (sampleChannel == currentChannel) {
|
||||
/* Continuation of the same channel. */
|
||||
/* Accumulate the byte length. */
|
||||
*componentByteLength += sampleByteLength;
|
||||
} else {
|
||||
/* Everything is new. Hopefully. */
|
||||
currentChannel = sampleChannel;
|
||||
(*numComponents)++;
|
||||
*componentByteLength = sampleByteLength;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Return the number of "components" in the data.
|
||||
*
|
||||
* Calculates the number of uniques samples in the DFD by combining
|
||||
* multiple samples for the same channel. For uncompressed colorModels
|
||||
* this is the same as the number of components in the image data. For
|
||||
* block-compressed color models this is the number of samples in
|
||||
* the color model, typically 1 and in a few cases 2.
|
||||
*
|
||||
* @param DFD Pointer to a Data Format Descriptor for which,
|
||||
* described as 32-bit words in native endianness.
|
||||
* Note that this is the whole descriptor, not just
|
||||
* the basic descriptor block.
|
||||
*/
|
||||
uint32_t getDFDNumComponents(const uint32_t* DFD)
|
||||
{
|
||||
const uint32_t *BDFDB = DFD+1;
|
||||
uint32_t currentChannel = ~0U; /* Don't start matched. */
|
||||
uint32_t numComponents = 0;
|
||||
uint32_t numSamples = KHR_DFDSAMPLECOUNT(BDFDB);
|
||||
uint32_t sampleNumber;
|
||||
|
||||
for (sampleNumber = 0; sampleNumber < numSamples; ++sampleNumber) {
|
||||
uint32_t sampleChannel = KHR_DFDSVAL(BDFDB, sampleNumber, CHANNELID);
|
||||
if (sampleChannel != currentChannel) {
|
||||
numComponents++;
|
||||
currentChannel = sampleChannel;
|
||||
}
|
||||
}
|
||||
return numComponents;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Reconstruct the value of bytesPlane0 from sample info.
|
||||
*
|
||||
* @deprecated Use reconstructDFDBytesPlanesFromSamples. This does not handle
|
||||
* the possible second plane of the ETC1S model.
|
||||
*
|
||||
* Reconstruct the value for data that has been variable-rate compressed
|
||||
* and and whose bytesPlane0 value has been set to 0. For DFDs that
|
||||
* are valid for KTX files. Little-endian data only and no multi-plane models
|
||||
* except ETC1S.
|
||||
*
|
||||
* @param DFD Pointer to the Data Format Descriptor for which to provide
|
||||
* the value described as 32-bit words in native endianness.
|
||||
* Note that this is the whole descriptor, not just
|
||||
* the basic descriptor block.
|
||||
* @return The number of bytes a pixel occupies in bytesPlane0.
|
||||
*/
|
||||
uint32_t
|
||||
reconstructDFDBytesPlane0FromSamples(const uint32_t* DFD)
|
||||
{
|
||||
const uint32_t *BDFDB = DFD+1;
|
||||
uint32_t numSamples = KHR_DFDSAMPLECOUNT(BDFDB);
|
||||
uint32_t sampleNumber;
|
||||
|
||||
uint32_t bitsPlane0 = 0;
|
||||
int32_t largestOffset = 0;
|
||||
uint32_t sampleNumberWithLargestOffset = 0;
|
||||
|
||||
// Special case these depth{,-stencil} formats. The unused bits are
|
||||
// in the MSBs so have no visibility in the DFD therefore the max offset
|
||||
// algorithm below returns a value that is too small.
|
||||
if (KHR_DFDSVAL(BDFDB, 0, CHANNELID) == KHR_DF_CHANNEL_COMMON_DEPTH) {
|
||||
if (numSamples == 1) {
|
||||
if (KHR_DFDSVAL(BDFDB, 0, BITLENGTH) + 1 == 24) {
|
||||
// X8_D24_UNORM_PACK32,
|
||||
return 4;
|
||||
}
|
||||
} else if (numSamples == 2) {
|
||||
if (KHR_DFDSVAL(BDFDB, 0, BITLENGTH) + 1 == 16) {
|
||||
// D16_UNORM_S8_UINT
|
||||
return 4;
|
||||
}
|
||||
if (KHR_DFDSVAL(BDFDB, 0, BITLENGTH) + 1 == 32
|
||||
&& KHR_DFDSVAL(BDFDB, 1, CHANNELID) == KHR_DF_CHANNEL_COMMON_STENCIL) {
|
||||
// D32_SFLOAT_S8_UINT
|
||||
return 8;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (KHR_DFDVAL(BDFDB, MODEL) == KHR_DF_MODEL_ETC1S) {
|
||||
// Size of the first plane.
|
||||
return 8;
|
||||
}
|
||||
for (sampleNumber = 0; sampleNumber < numSamples; ++sampleNumber) {
|
||||
int32_t sampleBitOffset = KHR_DFDSVAL(BDFDB, sampleNumber, BITOFFSET);
|
||||
if (sampleBitOffset > largestOffset) {
|
||||
largestOffset = sampleBitOffset;
|
||||
sampleNumberWithLargestOffset = sampleNumber;
|
||||
}
|
||||
}
|
||||
|
||||
/* The sample bitLength field stores the bit length - 1. */
|
||||
uint32_t sampleBitLength = KHR_DFDSVAL(BDFDB, sampleNumberWithLargestOffset, BITLENGTH) + 1;
|
||||
bitsPlane0 = largestOffset + sampleBitLength;
|
||||
return bitsPlane0 >> 3U;
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Reconstruct the values of bytesPlane[01] from sample info.
|
||||
*
|
||||
* Reconstruct the values for data that has been variable-rate compressed
|
||||
* and whose bytesPlane[01] values have been set to 0 and update the
|
||||
* fields of the target DFD. For DFDs that are valid for KTX files.
|
||||
* Little-endian data only and no multi-plane models except ETC1S hence
|
||||
* only looking at bytesPlane0 abd bytesPlane1.
|
||||
*
|
||||
* @param DFD Pointer to a Data Format Descriptor for which,
|
||||
* described as 32-bit words in native endianness.
|
||||
* Note that this is the whole descriptor, not just
|
||||
* the basic descriptor block.
|
||||
*/
|
||||
|
||||
void
|
||||
reconstructDFDBytesPlanesFromSamples(uint32_t* DFD)
|
||||
{
|
||||
uint32_t *BDFDB = DFD+1;
|
||||
|
||||
KHR_DFDSETVAL(BDFDB, BYTESPLANE0, reconstructDFDBytesPlane0FromSamples(DFD));
|
||||
if (KHR_DFDVAL(BDFDB, MODEL) == KHR_DF_MODEL_ETC1S) {
|
||||
if (KHR_DFDSAMPLECOUNT(BDFDB) == 2)
|
||||
KHR_DFDSETVAL(BDFDB, BYTESPLANE1, 8);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Reconstruct the value of bytesPlane0 from sample info.
|
||||
*
|
||||
* @see reconstructDFDBytesPlane0FromSamples for details.
|
||||
* @deprecated For backward comparibility only. Use
|
||||
* reconstructDFDBytesPlanesFromSamples.
|
||||
*
|
||||
* @param DFD Pointer to the Data Format Descriptor for which to provide
|
||||
* the value described as 32-bit words in native endianness.
|
||||
* Note that this is the whole descriptor, not just
|
||||
* the basic descriptor block.
|
||||
* @param bytesPlane0 pointer to a 32-bit word in which the recreated
|
||||
* value of bytesPlane0 will be written.
|
||||
*/
|
||||
void
|
||||
recreateBytesPlane0FromSampleInfo(const uint32_t* DFD, uint32_t* bytesPlane0)
|
||||
{
|
||||
*bytesPlane0 = reconstructDFDBytesPlane0FromSamples(DFD);
|
||||
}
|
34
thirdparty/libktx/external/dfdutils/vk2dfd.c
vendored
Normal file
34
thirdparty/libktx/external/dfdutils/vk2dfd.c
vendored
Normal file
@@ -0,0 +1,34 @@
|
||||
/* -*- tab-width: 4; -*- */
|
||||
/* vi: set sw=2 ts=4 expandtab: */
|
||||
|
||||
/* Copyright 2019-2020 Mark Callow
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file
|
||||
* @~English
|
||||
* @brief Create a DFD for a VkFormat.
|
||||
*/
|
||||
|
||||
#include "dfd.h"
|
||||
|
||||
/**
|
||||
* @~English
|
||||
* @brief Create a DFD matching a VkFormat.
|
||||
*
|
||||
* @param[in] format VkFormat for which to create a DFD.
|
||||
*
|
||||
* @return pointer to the created DFD or 0 if format not supported or
|
||||
* unrecognized. Caller is responsible for freeing the created
|
||||
* DFD.
|
||||
*/
|
||||
uint32_t*
|
||||
vk2dfd(enum VkFormat format)
|
||||
{
|
||||
switch (format) {
|
||||
#include "vk2dfd.inl"
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
410
thirdparty/libktx/external/dfdutils/vk2dfd.inl
vendored
Normal file
410
thirdparty/libktx/external/dfdutils/vk2dfd.inl
vendored
Normal file
@@ -0,0 +1,410 @@
|
||||
/* Copyright 2019-2020 The Khronos Group Inc. */
|
||||
/* SPDX-License-Identifier: Apache-2.0 */
|
||||
|
||||
/***************************** Do not edit. *****************************
|
||||
Automatically generated by makevk2dfd.pl.
|
||||
*************************************************************************/
|
||||
|
||||
case VK_FORMAT_R4G4_UNORM_PACK8: {
|
||||
int channels[] = {1,0}; int bits[] = {4,4};
|
||||
return createDFDPacked(0, 2, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R4G4B4A4_UNORM_PACK16: {
|
||||
int channels[] = {3,2,1,0}; int bits[] = {4,4,4,4};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B4G4R4A4_UNORM_PACK16: {
|
||||
int channels[] = {3,0,1,2}; int bits[] = {4,4,4,4};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R5G6B5_UNORM_PACK16: {
|
||||
int channels[] = {2,1,0}; int bits[] = {5,6,5};
|
||||
return createDFDPacked(0, 3, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B5G6R5_UNORM_PACK16: {
|
||||
int channels[] = {0,1,2}; int bits[] = {5,6,5};
|
||||
return createDFDPacked(0, 3, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R5G5B5A1_UNORM_PACK16: {
|
||||
int channels[] = {3,2,1,0}; int bits[] = {1,5,5,5};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B5G5R5A1_UNORM_PACK16: {
|
||||
int channels[] = {3,0,1,2}; int bits[] = {1,5,5,5};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A1R5G5B5_UNORM_PACK16: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {5,5,5,1};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R8_UNORM: return createDFDUnpacked(0, 1, 1, 0, s_UNORM);
|
||||
case VK_FORMAT_R8_SNORM: return createDFDUnpacked(0, 1, 1, 0, s_SNORM);
|
||||
case VK_FORMAT_R8_USCALED: return createDFDUnpacked(0, 1, 1, 0, s_USCALED);
|
||||
case VK_FORMAT_R8_SSCALED: return createDFDUnpacked(0, 1, 1, 0, s_SSCALED);
|
||||
case VK_FORMAT_R8_UINT: return createDFDUnpacked(0, 1, 1, 0, s_UINT);
|
||||
case VK_FORMAT_R8_SINT: return createDFDUnpacked(0, 1, 1, 0, s_SINT);
|
||||
case VK_FORMAT_R8_SRGB: return createDFDUnpacked(0, 1, 1, 0, s_SRGB);
|
||||
case VK_FORMAT_R8G8_UNORM: return createDFDUnpacked(0, 2, 1, 0, s_UNORM);
|
||||
case VK_FORMAT_R8G8_SNORM: return createDFDUnpacked(0, 2, 1, 0, s_SNORM);
|
||||
case VK_FORMAT_R8G8_USCALED: return createDFDUnpacked(0, 2, 1, 0, s_USCALED);
|
||||
case VK_FORMAT_R8G8_SSCALED: return createDFDUnpacked(0, 2, 1, 0, s_SSCALED);
|
||||
case VK_FORMAT_R8G8_UINT: return createDFDUnpacked(0, 2, 1, 0, s_UINT);
|
||||
case VK_FORMAT_R8G8_SINT: return createDFDUnpacked(0, 2, 1, 0, s_SINT);
|
||||
case VK_FORMAT_R8G8_SRGB: return createDFDUnpacked(0, 2, 1, 0, s_SRGB);
|
||||
case VK_FORMAT_R8G8B8_UNORM: return createDFDUnpacked(0, 3, 1, 0, s_UNORM);
|
||||
case VK_FORMAT_R8G8B8_SNORM: return createDFDUnpacked(0, 3, 1, 0, s_SNORM);
|
||||
case VK_FORMAT_R8G8B8_USCALED: return createDFDUnpacked(0, 3, 1, 0, s_USCALED);
|
||||
case VK_FORMAT_R8G8B8_SSCALED: return createDFDUnpacked(0, 3, 1, 0, s_SSCALED);
|
||||
case VK_FORMAT_R8G8B8_UINT: return createDFDUnpacked(0, 3, 1, 0, s_UINT);
|
||||
case VK_FORMAT_R8G8B8_SINT: return createDFDUnpacked(0, 3, 1, 0, s_SINT);
|
||||
case VK_FORMAT_R8G8B8_SRGB: return createDFDUnpacked(0, 3, 1, 0, s_SRGB);
|
||||
case VK_FORMAT_B8G8R8_UNORM: return createDFDUnpacked(0, 3, 1, 1, s_UNORM);
|
||||
case VK_FORMAT_B8G8R8_SNORM: return createDFDUnpacked(0, 3, 1, 1, s_SNORM);
|
||||
case VK_FORMAT_B8G8R8_USCALED: return createDFDUnpacked(0, 3, 1, 1, s_USCALED);
|
||||
case VK_FORMAT_B8G8R8_SSCALED: return createDFDUnpacked(0, 3, 1, 1, s_SSCALED);
|
||||
case VK_FORMAT_B8G8R8_UINT: return createDFDUnpacked(0, 3, 1, 1, s_UINT);
|
||||
case VK_FORMAT_B8G8R8_SINT: return createDFDUnpacked(0, 3, 1, 1, s_SINT);
|
||||
case VK_FORMAT_B8G8R8_SRGB: return createDFDUnpacked(0, 3, 1, 1, s_SRGB);
|
||||
case VK_FORMAT_R8G8B8A8_UNORM: return createDFDUnpacked(0, 4, 1, 0, s_UNORM);
|
||||
case VK_FORMAT_R8G8B8A8_SNORM: return createDFDUnpacked(0, 4, 1, 0, s_SNORM);
|
||||
case VK_FORMAT_R8G8B8A8_USCALED: return createDFDUnpacked(0, 4, 1, 0, s_USCALED);
|
||||
case VK_FORMAT_R8G8B8A8_SSCALED: return createDFDUnpacked(0, 4, 1, 0, s_SSCALED);
|
||||
case VK_FORMAT_R8G8B8A8_UINT: return createDFDUnpacked(0, 4, 1, 0, s_UINT);
|
||||
case VK_FORMAT_R8G8B8A8_SINT: return createDFDUnpacked(0, 4, 1, 0, s_SINT);
|
||||
case VK_FORMAT_R8G8B8A8_SRGB: return createDFDUnpacked(0, 4, 1, 0, s_SRGB);
|
||||
case VK_FORMAT_B8G8R8A8_UNORM: return createDFDUnpacked(0, 4, 1, 1, s_UNORM);
|
||||
case VK_FORMAT_B8G8R8A8_SNORM: return createDFDUnpacked(0, 4, 1, 1, s_SNORM);
|
||||
case VK_FORMAT_B8G8R8A8_USCALED: return createDFDUnpacked(0, 4, 1, 1, s_USCALED);
|
||||
case VK_FORMAT_B8G8R8A8_SSCALED: return createDFDUnpacked(0, 4, 1, 1, s_SSCALED);
|
||||
case VK_FORMAT_B8G8R8A8_UINT: return createDFDUnpacked(0, 4, 1, 1, s_UINT);
|
||||
case VK_FORMAT_B8G8R8A8_SINT: return createDFDUnpacked(0, 4, 1, 1, s_SINT);
|
||||
case VK_FORMAT_B8G8R8A8_SRGB: return createDFDUnpacked(0, 4, 1, 1, s_SRGB);
|
||||
case VK_FORMAT_A8B8G8R8_UNORM_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_SNORM_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SNORM);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_USCALED_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_USCALED);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SSCALED);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_UINT_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UINT);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_SINT_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SINT);
|
||||
}
|
||||
case VK_FORMAT_A8B8G8R8_SRGB_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {8,8,8,8};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SRGB);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_UNORM_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_SNORM_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SNORM);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_USCALED_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_USCALED);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SSCALED);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_UINT_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UINT);
|
||||
}
|
||||
case VK_FORMAT_A2R10G10B10_SINT_PACK32: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SINT);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_UNORM_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_SNORM_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SNORM);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_USCALED_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_USCALED);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SSCALED);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_UINT_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UINT);
|
||||
}
|
||||
case VK_FORMAT_A2B10G10R10_SINT_PACK32: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {10,10,10,2};
|
||||
return createDFDPacked(0, 4, bits, channels, s_SINT);
|
||||
}
|
||||
case VK_FORMAT_R16_UNORM: return createDFDUnpacked(0, 1, 2, 0, s_UNORM);
|
||||
case VK_FORMAT_R16_SNORM: return createDFDUnpacked(0, 1, 2, 0, s_SNORM);
|
||||
case VK_FORMAT_R16_USCALED: return createDFDUnpacked(0, 1, 2, 0, s_USCALED);
|
||||
case VK_FORMAT_R16_SSCALED: return createDFDUnpacked(0, 1, 2, 0, s_SSCALED);
|
||||
case VK_FORMAT_R16_UINT: return createDFDUnpacked(0, 1, 2, 0, s_UINT);
|
||||
case VK_FORMAT_R16_SINT: return createDFDUnpacked(0, 1, 2, 0, s_SINT);
|
||||
case VK_FORMAT_R16_SFLOAT: return createDFDUnpacked(0, 1, 2, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R16G16_UNORM: return createDFDUnpacked(0, 2, 2, 0, s_UNORM);
|
||||
case VK_FORMAT_R16G16_SNORM: return createDFDUnpacked(0, 2, 2, 0, s_SNORM);
|
||||
case VK_FORMAT_R16G16_USCALED: return createDFDUnpacked(0, 2, 2, 0, s_USCALED);
|
||||
case VK_FORMAT_R16G16_SSCALED: return createDFDUnpacked(0, 2, 2, 0, s_SSCALED);
|
||||
case VK_FORMAT_R16G16_UINT: return createDFDUnpacked(0, 2, 2, 0, s_UINT);
|
||||
case VK_FORMAT_R16G16_SINT: return createDFDUnpacked(0, 2, 2, 0, s_SINT);
|
||||
case VK_FORMAT_R16G16_SFLOAT: return createDFDUnpacked(0, 2, 2, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R16G16B16_UNORM: return createDFDUnpacked(0, 3, 2, 0, s_UNORM);
|
||||
case VK_FORMAT_R16G16B16_SNORM: return createDFDUnpacked(0, 3, 2, 0, s_SNORM);
|
||||
case VK_FORMAT_R16G16B16_USCALED: return createDFDUnpacked(0, 3, 2, 0, s_USCALED);
|
||||
case VK_FORMAT_R16G16B16_SSCALED: return createDFDUnpacked(0, 3, 2, 0, s_SSCALED);
|
||||
case VK_FORMAT_R16G16B16_UINT: return createDFDUnpacked(0, 3, 2, 0, s_UINT);
|
||||
case VK_FORMAT_R16G16B16_SINT: return createDFDUnpacked(0, 3, 2, 0, s_SINT);
|
||||
case VK_FORMAT_R16G16B16_SFLOAT: return createDFDUnpacked(0, 3, 2, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R16G16B16A16_UNORM: return createDFDUnpacked(0, 4, 2, 0, s_UNORM);
|
||||
case VK_FORMAT_R16G16B16A16_SNORM: return createDFDUnpacked(0, 4, 2, 0, s_SNORM);
|
||||
case VK_FORMAT_R16G16B16A16_USCALED: return createDFDUnpacked(0, 4, 2, 0, s_USCALED);
|
||||
case VK_FORMAT_R16G16B16A16_SSCALED: return createDFDUnpacked(0, 4, 2, 0, s_SSCALED);
|
||||
case VK_FORMAT_R16G16B16A16_UINT: return createDFDUnpacked(0, 4, 2, 0, s_UINT);
|
||||
case VK_FORMAT_R16G16B16A16_SINT: return createDFDUnpacked(0, 4, 2, 0, s_SINT);
|
||||
case VK_FORMAT_R16G16B16A16_SFLOAT: return createDFDUnpacked(0, 4, 2, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R32_UINT: return createDFDUnpacked(0, 1, 4, 0, s_UINT);
|
||||
case VK_FORMAT_R32_SINT: return createDFDUnpacked(0, 1, 4, 0, s_SINT);
|
||||
case VK_FORMAT_R32_SFLOAT: return createDFDUnpacked(0, 1, 4, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R32G32_UINT: return createDFDUnpacked(0, 2, 4, 0, s_UINT);
|
||||
case VK_FORMAT_R32G32_SINT: return createDFDUnpacked(0, 2, 4, 0, s_SINT);
|
||||
case VK_FORMAT_R32G32_SFLOAT: return createDFDUnpacked(0, 2, 4, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R32G32B32_UINT: return createDFDUnpacked(0, 3, 4, 0, s_UINT);
|
||||
case VK_FORMAT_R32G32B32_SINT: return createDFDUnpacked(0, 3, 4, 0, s_SINT);
|
||||
case VK_FORMAT_R32G32B32_SFLOAT: return createDFDUnpacked(0, 3, 4, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R32G32B32A32_UINT: return createDFDUnpacked(0, 4, 4, 0, s_UINT);
|
||||
case VK_FORMAT_R32G32B32A32_SINT: return createDFDUnpacked(0, 4, 4, 0, s_SINT);
|
||||
case VK_FORMAT_R32G32B32A32_SFLOAT: return createDFDUnpacked(0, 4, 4, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R64_UINT: return createDFDUnpacked(0, 1, 8, 0, s_UINT);
|
||||
case VK_FORMAT_R64_SINT: return createDFDUnpacked(0, 1, 8, 0, s_SINT);
|
||||
case VK_FORMAT_R64_SFLOAT: return createDFDUnpacked(0, 1, 8, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R64G64_UINT: return createDFDUnpacked(0, 2, 8, 0, s_UINT);
|
||||
case VK_FORMAT_R64G64_SINT: return createDFDUnpacked(0, 2, 8, 0, s_SINT);
|
||||
case VK_FORMAT_R64G64_SFLOAT: return createDFDUnpacked(0, 2, 8, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R64G64B64_UINT: return createDFDUnpacked(0, 3, 8, 0, s_UINT);
|
||||
case VK_FORMAT_R64G64B64_SINT: return createDFDUnpacked(0, 3, 8, 0, s_SINT);
|
||||
case VK_FORMAT_R64G64B64_SFLOAT: return createDFDUnpacked(0, 3, 8, 0, s_SFLOAT);
|
||||
case VK_FORMAT_R64G64B64A64_UINT: return createDFDUnpacked(0, 4, 8, 0, s_UINT);
|
||||
case VK_FORMAT_R64G64B64A64_SINT: return createDFDUnpacked(0, 4, 8, 0, s_SINT);
|
||||
case VK_FORMAT_R64G64B64A64_SFLOAT: return createDFDUnpacked(0, 4, 8, 0, s_SFLOAT);
|
||||
case VK_FORMAT_B10G11R11_UFLOAT_PACK32: {
|
||||
int channels[] = {0,1,2}; int bits[] = {11,11,10};
|
||||
return createDFDPacked(0, 3, bits, channels, s_UFLOAT);
|
||||
}
|
||||
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: {
|
||||
int bits[] = {0}; int channels[] = {0};
|
||||
return createDFDPacked(0, 6, bits, channels, s_UFLOAT);
|
||||
}
|
||||
case VK_FORMAT_D16_UNORM: return createDFDDepthStencil(16,0,2);
|
||||
case VK_FORMAT_X8_D24_UNORM_PACK32: return createDFDDepthStencil(24,0,4);
|
||||
case VK_FORMAT_D32_SFLOAT: return createDFDDepthStencil(32,0,4);
|
||||
case VK_FORMAT_S8_UINT: return createDFDDepthStencil(0,8,1);
|
||||
case VK_FORMAT_D16_UNORM_S8_UINT: return createDFDDepthStencil(16,8,4);
|
||||
case VK_FORMAT_D24_UNORM_S8_UINT: return createDFDDepthStencil(24,8,4);
|
||||
case VK_FORMAT_D32_SFLOAT_S8_UINT: return createDFDDepthStencil(32,8,8);
|
||||
case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return createDFDCompressed(c_BC1_RGB, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return createDFDCompressed(c_BC1_RGB, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return createDFDCompressed(c_BC1_RGBA, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return createDFDCompressed(c_BC1_RGBA, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_BC2_UNORM_BLOCK: return createDFDCompressed(c_BC2, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC2_SRGB_BLOCK: return createDFDCompressed(c_BC2, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_BC3_UNORM_BLOCK: return createDFDCompressed(c_BC3, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC3_SRGB_BLOCK: return createDFDCompressed(c_BC3, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_BC4_UNORM_BLOCK: return createDFDCompressed(c_BC4, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC4_SNORM_BLOCK: return createDFDCompressed(c_BC4, 4, 4, 1, s_SNORM);
|
||||
case VK_FORMAT_BC5_UNORM_BLOCK: return createDFDCompressed(c_BC5, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC5_SNORM_BLOCK: return createDFDCompressed(c_BC5, 4, 4, 1, s_SNORM);
|
||||
case VK_FORMAT_BC6H_UFLOAT_BLOCK: return createDFDCompressed(c_BC6H, 4, 4, 1, s_UFLOAT);
|
||||
case VK_FORMAT_BC6H_SFLOAT_BLOCK: return createDFDCompressed(c_BC6H, 4, 4, 1, s_SFLOAT);
|
||||
case VK_FORMAT_BC7_UNORM_BLOCK: return createDFDCompressed(c_BC7, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_BC7_SRGB_BLOCK: return createDFDCompressed(c_BC7, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8A1, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8A1, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8A8, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return createDFDCompressed(c_ETC2_R8G8B8A8, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_EAC_R11_UNORM_BLOCK: return createDFDCompressed(c_EAC_R11, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_EAC_R11_SNORM_BLOCK: return createDFDCompressed(c_EAC_R11, 4, 4, 1, s_SNORM);
|
||||
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return createDFDCompressed(c_EAC_R11G11, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return createDFDCompressed(c_EAC_R11G11, 4, 4, 1, s_SNORM);
|
||||
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 5, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 5, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 5, 5, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 5, 5, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 6, 5, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 6, 5, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 6, 6, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 6, 6, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 8, 5, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 8, 5, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 8, 6, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 8, 6, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 8, 8, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 8, 8, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 10, 5, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 10, 5, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 10, 6, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 10, 6, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 10, 8, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 10, 8, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 10, 10, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 10, 10, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 12, 10, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 12, 10, 1, s_SRGB);
|
||||
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return createDFDCompressed(c_ASTC, 12, 12, 1, s_UNORM);
|
||||
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return createDFDCompressed(c_ASTC, 12, 12, 1, s_SRGB);
|
||||
case VK_FORMAT_G8B8G8R8_422_UNORM: {
|
||||
int channels[] = {0, 1, 0, 2}; int bits[] = {8, 8, 8, 8}; int shiftBits[] = {0, 0, 0, 0};
|
||||
int position_xs[] = {64, 64, 192, 64}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B8G8R8G8_422_UNORM: {
|
||||
int channels[] = {1, 0, 2, 0}; int bits[] = {8, 8, 8, 8}; int shiftBits[] = {0, 0, 0, 0};
|
||||
int position_xs[] = {64, 64, 64, 192}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R10X6_UNORM_PACK16: {
|
||||
int channels[] = {0}; int bits[] = {10}; int shiftBits[] = {6};
|
||||
return createDFDPackedShifted(0, 1, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: {
|
||||
int channels[] = {0, 1}; int bits[] = {10, 10}; int shiftBits[] = {6, 6};
|
||||
return createDFDPackedShifted(0, 2, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: {
|
||||
int channels[] = {0, 1, 2, 3}; int bits[] = {10, 10, 10, 10}; int shiftBits[] = {6, 6, 6, 6};
|
||||
return createDFDPackedShifted(0, 4, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: {
|
||||
int channels[] = {0, 1, 0, 2}; int bits[] = {10, 10, 10, 10}; int shiftBits[] = {6, 6, 6, 6};
|
||||
int position_xs[] = {64, 64, 192, 64}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: {
|
||||
int channels[] = {1, 0, 2, 0}; int bits[] = {10, 10, 10, 10}; int shiftBits[] = {6, 6, 6, 6};
|
||||
int position_xs[] = {64, 64, 64, 192}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R12X4_UNORM_PACK16: {
|
||||
int channels[] = {0}; int bits[] = {12}; int shiftBits[] = {4};
|
||||
return createDFDPackedShifted(0, 1, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: {
|
||||
int channels[] = {0, 1}; int bits[] = {12, 12}; int shiftBits[] = {4, 4};
|
||||
return createDFDPackedShifted(0, 2, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: {
|
||||
int channels[] = {0, 1, 2, 3}; int bits[] = {12, 12, 12, 12}; int shiftBits[] = {4, 4, 4, 4};
|
||||
return createDFDPackedShifted(0, 4, bits, shiftBits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: {
|
||||
int channels[] = {0, 1, 0, 2}; int bits[] = {12, 12, 12, 12}; int shiftBits[] = {4, 4, 4, 4};
|
||||
int position_xs[] = {64, 64, 192, 64}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: {
|
||||
int channels[] = {1, 0, 2, 0}; int bits[] = {12, 12, 12, 12}; int shiftBits[] = {4, 4, 4, 4};
|
||||
int position_xs[] = {64, 64, 64, 192}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_G16B16G16R16_422_UNORM: {
|
||||
int channels[] = {0, 1, 0, 2}; int bits[] = {16, 16, 16, 16}; int shiftBits[] = {0, 0, 0, 0};
|
||||
int position_xs[] = {64, 64, 192, 64}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_B16G16R16G16_422_UNORM: {
|
||||
int channels[] = {1, 0, 2, 0}; int bits[] = {16, 16, 16, 16}; int shiftBits[] = {0, 0, 0, 0};
|
||||
int position_xs[] = {64, 64, 64, 192}; int position_ys[] = {128, 128, 128, 128};
|
||||
return createDFD422(0, 4, bits, shiftBits, channels, position_xs, position_ys, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A4R4G4B4_UNORM_PACK16: {
|
||||
int channels[] = {2,1,0,3}; int bits[] = {4,4,4,4};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A4B4G4R4_UNORM_PACK16: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {4,4,4,4};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 4, 4, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 5, 4, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 5, 5, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 6, 5, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 6, 6, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 8, 5, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 8, 6, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 8, 8, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 10, 5, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 10, 6, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 10, 8, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 10, 10, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 12, 10, 1, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: return createDFDCompressed(c_ASTC, 12, 12, 1, s_SFLOAT);
|
||||
case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: return createDFDCompressed(c_PVRTC, 8, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: return createDFDCompressed(c_PVRTC, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: return createDFDCompressed(c_PVRTC2, 8, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: return createDFDCompressed(c_PVRTC2, 4, 4, 1, s_UNORM);
|
||||
case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: return createDFDCompressed(c_PVRTC, 8, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: return createDFDCompressed(c_PVRTC, 4, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: return createDFDCompressed(c_PVRTC2, 8, 4, 1, s_SRGB);
|
||||
case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: return createDFDCompressed(c_PVRTC2, 4, 4, 1, s_SRGB);
|
||||
#if 0
|
||||
case VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 3, 3, 3, s_UNORM);
|
||||
case VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 3, 3, 3, s_SRGB);
|
||||
case VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 3, 3, 3, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 3, 3, s_UNORM);
|
||||
case VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 3, 3, s_SRGB);
|
||||
case VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 3, 3, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 3, s_UNORM);
|
||||
case VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 3, s_SRGB);
|
||||
case VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 3, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 4, s_UNORM);
|
||||
case VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 4, s_SRGB);
|
||||
case VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 4, 4, 4, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 4, 4, s_UNORM);
|
||||
case VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 4, 4, s_SRGB);
|
||||
case VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 4, 4, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 4, s_UNORM);
|
||||
case VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 4, s_SRGB);
|
||||
case VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 4, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 5, s_UNORM);
|
||||
case VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 5, s_SRGB);
|
||||
case VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 5, 5, 5, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 5, 5, s_UNORM);
|
||||
case VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 5, 5, s_SRGB);
|
||||
case VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 5, 5, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 5, s_UNORM);
|
||||
case VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 5, s_SRGB);
|
||||
case VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 5, s_SFLOAT);
|
||||
case VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 6, s_UNORM);
|
||||
case VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 6, s_SRGB);
|
||||
case VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: return createDFDCompressed(c_ASTC, 6, 6, 6, s_SFLOAT);
|
||||
#endif
|
||||
case VK_FORMAT_R16G16_SFIXED5_NV: return createDFDUnpacked(0, 2, 2, 0, s_SFIXED5);
|
||||
case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: {
|
||||
int channels[] = {0,1,2,3}; int bits[] = {5,5,5,1};
|
||||
return createDFDPacked(0, 4, bits, channels, s_UNORM);
|
||||
}
|
||||
case VK_FORMAT_A8_UNORM_KHR: return createDFDAlpha(0, 1, s_UNORM);
|
Reference in New Issue
Block a user