Surface Formats

A surface format describes the encoding of color information into the actual data stored in memory. Surface formats in isl are specified via the isl_format enum. A complete list of surface formats is included at the end of this chapter.

In general, a surface format definition consists of two parts: encoding and layout.

Data Encoding

There are several different ways that one can encode a number (or vector) into a binary form, and each makes different trade-offs. By default, most color values lie in the range [0, 1], so one of the most common encodings for color data is unsigned normalized where the range of an unsigned integer of a particular size is mapped linearly onto the interval [0, 1]. While normalized is certainly the most common representation for color data, not all data is color data, and not all values are nicely bounded. The possible data encodings are specified by isl_base_type:

enum isl_base_type

Numerical base type for channels of isl_format.


enumerator ISL_VOID

Data which takes up space but is ignored

enumerator ISL_RAW

Data in a “raw” form and cannot be easily interpreted

enumerator ISL_UNORM

Unsigned normalized data

Though stored as an integer, the data is interpreted as a floating-point number in the range [0, 1] where the conversion from the in-memory representation to float is given by \(\frac{x}{2^{bits} - 1}\).

enumerator ISL_SNORM

Signed normalized data

Though stored as an integer, the data is interpreted as a floating-point number in the range [-1, 1] where the conversion from the in-memory representation to float is given by \(max\left(\frac{x}{2^{bits - 1} - 1}, -1\right)\).

enumerator ISL_UFLOAT

Unsigned floating-point data

Unlike the standard IEEE floating-point representation, unsigned floating-point data has no sign bit. This saves a bit of space which is important if more than one float is required to represent a color value. As with IEEE floats, the high bits are the exponent and the low bits are the mantissa. The available bit sizes for unsigned floats are as follows:










In particular, both unsigned floating-point formats are identical to IEEE float16 except that the sign bit and the bottom mantissa bits are removed.

enumerator ISL_SFLOAT

Signed floating-point data

Signed floating-point data is represented as standard IEEE floats with the usual number of mantissa and exponent bits













enumerator ISL_UFIXED

Unsigned fixed-point data

This is a 32-bit unsigned integer that is interpreted as a 16.16 fixed-point value.

enumerator ISL_SFIXED

Signed fixed-point data

This is a 32-bit signed integer that is interpreted as a 16.16 fixed-point value.

enumerator ISL_UINT

Unsigned integer data

enumerator ISL_SINT

Signed integer data

enumerator ISL_USCALED

Unsigned scaled data

This is data which is stored as an unsigned integer but interpreted as a floating-point value by the hardware. The re-interpretation is done via a simple unsigned integer to float cast. This is typically used as a vertex format.

enumerator ISL_SSCALED

Signed scaled data

This is data which is stored as a signed integer but interpreted as a floating-point value by the hardware. The re-interpretation is done via a simple signed integer to float cast. This is typically used as a vertex format.

Data Layout

The different data layouts fall into two categories: array and packed. When an array layout is used, the components are stored sequentially in an array of the given encoding. For instance, if the data is encoded in an 8-bit RGBA array format the data is stored in an array of type uint8_t where the blue component of the i’th color value is accessed as:

uint8_t r = ((uint8_t *)data)[i * 4 + 0];
uint8_t g = ((uint8_t *)data)[i * 4 + 1];
uint8_t b = ((uint8_t *)data)[i * 4 + 2];
uint8_t a = ((uint8_t *)data)[i * 4 + 3];

Array formats are popular because of their simplicity. However, they are limited to formats where all components have the same size and fit in a standard C data type.

Packed formats, on the other hand, are encoded with the entire color value packed into a single 8, 16, or 32-bit value. The components are specified by which bits they occupy within that value. For instance, with the popular RGB565 format, each vec3 takes up 16 bits and the i’th color value is accessed as:

uint8_t r = (*(uint16_t *)data >> 0) & 0x1f;
uint8_t g = (*(uint16_t *)data >> 5) & 0x3f;
uint8_t b = (*(uint16_t *)data >> 11) & 0x1f;

Packed formats are useful because they allow you to specify formats with uneven component sizes such as RGBA1010102 or where the components are smaller than 8 bits such as RGB565 discussed above. It does, however, come with the restriction that the entire vector must fit within 8, 16, or 32 bits.

One has to be careful when reasoning about packed formats because it is easy to get the color order wrong. With array formats, the channel ordering is usually implied directly from the format name with RGBA8888 storing the formats as in the first example and BGRA8888 storing them in the BGRA ordering. Packed formats, however, are not as simple because some specifications choose to use a MSB to LSB ordering and others LSB to MSB. One must be careful to pay attention to the enum in question in order to avoid getting them backwards.

From an API perspective, both types of formats are available. In Vulkan, the formats that are of the form VK_FORMAT_xxx_PACKEDn are packed formats where the entire color fits in n bits and formats without the _PACKEDn suffix are array formats. In GL, if you specify one of the base types such as GL_FLOAT you get an array format but if you specify a packed type such as GL_UNSIGNED_INT_8_8_8_8_REV you get a packed format.

The following table provides a summary of the bit orderings of different packed format specifications. The bit ordering is relative to the reading of the enum name from left to right.


Left → Right







Intel surface format


Understanding sRGB

The sRGB colorspace is one of the least tractable concepts in the entire world of surfaces and formats. Most texture formats are stored in a linear colorspace where the floating-point value corresponds linearly to intensity values. The sRGB color space, on the other hand, is non-linear and provides greater precision in the lower-intensity (darker) end of the spectrum. The relationship between linear and sRGB is governed by the following continuous bijection:

\[\begin{split}c_l = \begin{cases} \frac{c_s}{12.92} &\text{if } c_s \le 0.04045 \\\\ \left(\frac{c_s + 0.055}{1.055}\right)^{2.4} &\text{if } c_s > 0.04045 \end{cases}\end{split}\]

where \(c_l\) is the linear color and \(c_s\) is the color in sRGB. It is important to note that, when an alpha channel is present, the alpha channel is always stored in the linear colorspace.

The key to understanding sRGB is to think about it starting from the physical display. All displays work natively in sRGB. On older displays, there isn’t so much a conversion operation as a fact of how the hardware works. All display hardware has a natural gamma curve required to get from linear to the signal level required to generate the correct color. On older CRT displays, the gamma curve of your average CRT is approximately the sRGB curve. More modern display hardware has support for additional gamma curves to try and get accurate colors but, for the sake of compatibility, everything still operates in sRGB. When an image is sent to the X server, X passes the pixels on to the display verbatim without doing any conversions. (Fun fact: When dealing with translucent windows, X blends in the wrong colorspace.) This means that the image into which you are rendering will always be interpreted as if it were in the sRGB colorspace.

When sampling from a texture, the value returned to the shader is in the linear colorspace. The conversion from sRGB happens as part of sampling. In OpenGL, thanks mostly to history, there are various knobs for determining when you should or should not encode or decode sRGB. In 2007, GL_EXT_texture_sRGB added support for sRGB texture formats and was included in OpenGL 2.1. In 2010, GL_EXT_texture_sRGB_decode added a flag to allow you to disable texture decoding so that the shader received the data still in the sRGB colorspace. Then, in 2012, GL_ARB_texture_view came along and made GL_EXT_texture_sRGB_decode simultaneously obsolete and very confusing. Now, thanks to the combination of extensions, you can upload a texture as linear, create an sRGB view of it and ask that sRGB not be decoded. What format is it in again?

The situation with render targets is a bit different. Historically, you got your render target from the window system (which is always sRGB) and the spec said nothing whatsoever about encoding. All render targets were sRGB because that’s how monitors worked and application writers were expected to understand that their final rendering needed to be in sRGB. However, with the advent of GL_EXT_framebuffer_object this was no longer true. Also, sRGB was causing problems with blending because GL was blind to the fact that the output was sRGB and blending was occurring in the wrong colorspace. In 2006, a set of GL_EXT_framebuffer_sRGB extensions added support (on both the GL and window-system sides) for detecting whether a particular framebuffer was in sRGB and instructing GL to do the conversion into the sRGB colorspace as the final step prior to writing out to the render target. Enabling sRGB also implied that blending would occur in the linear colorspace prior to sRGB conversion and would therefore be more accurate. When sRGB was added to the OpenGL ES spec in 3.1, they added the query for sRGB but did not add the flag to allow you to turn it on and off.

In Vulkan, this is all much more straightforward. Your format is sRGB or it isn’t. If you have an sRGB image and you don’t want sRGB decoding to happen when you sample from it, you simply create a VkImageView that has the appropriate linear format and the data will be treated as linear and not converted. Similarly for render targets, blending always happens in the same colorspace as the shader output and you determine whether or not you want sRGB conversion by the format of the VkImageView used as the render target.

Surface Format Introspection API

ISL provides an API for introspecting the isl_format enum and getting various bits of information about a format. ISL provides helpers for introspecting both the data layout of an isl_format and the capabilities of that format for a particular piece of Intel hardware.

Format Layout Introspection

To get the layout of a given isl_format, call isl_format_get_layout():

static inline const struct isl_format_layout *isl_format_get_layout(enum isl_format fmt)

The isl_format_layout for the given isl_format

struct isl_format_layout

Describes the layout of an isl_format

Each format has 3D block extent (width, height, depth). The block extent of compressed formats is that of the format’s compression block. For example, the block extent of ISL_FORMAT_ETC2_RGB8 is (w=4, h=4, d=1). The block extent of uncompressed pixel formats, such as ISL_FORMAT_R8G8B8A8_UNORM, is (w=1, h=1, d=1).

Public Members

enum isl_format format


uint16_t bpb

Bits per block

uint8_t bw

Block width, in pixels

uint8_t bh

Block height, in pixels

uint8_t bd

Block depth, in pixels

struct isl_channel_layout r

Red channel

struct isl_channel_layout g

Green channel

struct isl_channel_layout b

Blue channel

struct isl_channel_layout a

Alpha channel

struct isl_channel_layout l

Luminance channel

struct isl_channel_layout i

Intensity channel

struct isl_channel_layout p

Palette channel

enum isl_base_type uniform_channel_type

Set if all channels have the same isl_base_type. Otherwise, ISL_VOID.

struct isl_channel_layout

Describes a single channel of an isl_format

Public Members

enum isl_base_type type

Channel data encoding

uint8_t start_bit

Bit at which this channel starts

uint8_t bits

Size in bits

There are also quite a few helpers for many of the common cases that allow you to avoid using isl_format_layout manually. There are a lot of them so we won’t include a full list here. Look at isl.h for more details.

Hardware Format Support Introspection

This is provided by means of a table located in isl_format.c. Looking at the table directly is often useful for understanding HW support for various formats. However, for the purposes of code cleanliness, the table is not exposed directly and, instead, hardware support information is exposed via a set of helper functions:

bool isl_format_supports_rendering(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_format_supports_alpha_blending(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_format_supports_sampling(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_format_supports_filtering(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_format_supports_vertex_fetch(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_format_supports_typed_writes(const struct intel_device_info *devinfo, enum isl_format format)

Returns true if the given format can support typed writes.

bool isl_format_supports_typed_reads(const struct intel_device_info *devinfo, enum isl_format format)

Returns true if the given format can support typed reads with format conversion fully handled by hardware. On Sky Lake, all formats which are supported for typed writes also support typed reads but some of them return the raw image data and don’t provide format conversion.

For anyone looking to find this data in the PRM, the easiest way to find format tables is to search for R11G11B10. There are only a few occurrences.

bool isl_format_supports_ccs_d(const struct intel_device_info *devinfo, enum isl_format format)

Returns true if the given format can support single-sample fast clears. This function only checks the format. In order to determine if a surface supports CCS_E, several other factors need to be considered such as tiling and sample count. See isl_surf_get_ccs_surf for details.

bool isl_format_supports_ccs_e(const struct intel_device_info *devinfo, enum isl_format format)

Returns true if the given format can support single-sample color compression. This function only checks the format. In order to determine if a surface supports CCS_E, several other factors need to be considered such as tiling and sample count. See isl_surf_get_ccs_surf for details.

bool isl_format_supports_multisampling(const struct intel_device_info *devinfo, enum isl_format format)
bool isl_formats_are_ccs_e_compatible(const struct intel_device_info *devinfo, enum isl_format format1, enum isl_format format2)

Returns true if the two formats are “CCS_E compatible” meaning that you can render in one format with CCS_E enabled and then texture using the other format without needing a resolve.

Note: Even if the formats are compatible, special care must be taken if a clear color is involved because the encoding of the clear color is heavily format-dependent.

Surface Format Enums

Everything in ISL is done in terms of the isl_format enum. However, for the sake of interacting with other parts of Mesa, we provide a helper for converting a pipe_format to an isl_format:

enum isl_format isl_format_for_pipe_format(enum pipe_format pf)

The isl_format enum is as follows:

enum isl_format

Hardware enumeration SURFACE_FORMAT.

For the official list, see Broadwell PRM: Volume 2b: Command Reference: Enumerations: SURFACE_FORMAT.


enumerator ISL_FORMAT_R32G32B32A32_FLOAT = 0
enumerator ISL_FORMAT_R32G32B32A32_SINT = 1
enumerator ISL_FORMAT_R32G32B32A32_UINT = 2
enumerator ISL_FORMAT_R32G32B32A32_UNORM = 3
enumerator ISL_FORMAT_R32G32B32A32_SNORM = 4
enumerator ISL_FORMAT_R64G64_FLOAT = 5
enumerator ISL_FORMAT_R32G32B32X32_FLOAT = 6
enumerator ISL_FORMAT_R32G32B32A32_SSCALED = 7
enumerator ISL_FORMAT_R32G32B32A32_USCALED = 8
enumerator ISL_FORMAT_R32G32B32A32_SFIXED = 32
enumerator ISL_FORMAT_R64G64_PASSTHRU = 33
enumerator ISL_FORMAT_R32G32B32_FLOAT = 64
enumerator ISL_FORMAT_R32G32B32_SINT = 65
enumerator ISL_FORMAT_R32G32B32_UINT = 66
enumerator ISL_FORMAT_R32G32B32_UNORM = 67
enumerator ISL_FORMAT_R32G32B32_SNORM = 68
enumerator ISL_FORMAT_R32G32B32_SSCALED = 69
enumerator ISL_FORMAT_R32G32B32_USCALED = 70
enumerator ISL_FORMAT_R32G32B32_SFIXED = 80
enumerator ISL_FORMAT_R16G16B16A16_UNORM = 128
enumerator ISL_FORMAT_R16G16B16A16_SNORM = 129
enumerator ISL_FORMAT_R16G16B16A16_SINT = 130
enumerator ISL_FORMAT_R16G16B16A16_UINT = 131
enumerator ISL_FORMAT_R16G16B16A16_FLOAT = 132
enumerator ISL_FORMAT_R32G32_FLOAT = 133
enumerator ISL_FORMAT_R32G32_SINT = 134
enumerator ISL_FORMAT_R32G32_UINT = 135
enumerator ISL_FORMAT_R32_FLOAT_X8X24_TYPELESS = 136
enumerator ISL_FORMAT_X32_TYPELESS_G8X24_UINT = 137
enumerator ISL_FORMAT_L32A32_FLOAT = 138
enumerator ISL_FORMAT_R32G32_UNORM = 139
enumerator ISL_FORMAT_R32G32_SNORM = 140
enumerator ISL_FORMAT_R64_FLOAT = 141
enumerator ISL_FORMAT_R16G16B16X16_UNORM = 142
enumerator ISL_FORMAT_R16G16B16X16_FLOAT = 143
enumerator ISL_FORMAT_A32X32_FLOAT = 144
enumerator ISL_FORMAT_L32X32_FLOAT = 145
enumerator ISL_FORMAT_I32X32_FLOAT = 146
enumerator ISL_FORMAT_R16G16B16A16_SSCALED = 147
enumerator ISL_FORMAT_R16G16B16A16_USCALED = 148
enumerator ISL_FORMAT_R32G32_SSCALED = 149
enumerator ISL_FORMAT_R32G32_USCALED = 150
enumerator ISL_FORMAT_R32G32_FLOAT_LD = 151
enumerator ISL_FORMAT_R32G32_SFIXED = 160
enumerator ISL_FORMAT_R64_PASSTHRU = 161
enumerator ISL_FORMAT_B8G8R8A8_UNORM = 192
enumerator ISL_FORMAT_B8G8R8A8_UNORM_SRGB = 193
enumerator ISL_FORMAT_R10G10B10A2_UNORM = 194
enumerator ISL_FORMAT_R10G10B10A2_UNORM_SRGB = 195
enumerator ISL_FORMAT_R10G10B10A2_UINT = 196
enumerator ISL_FORMAT_R10G10B10_SNORM_A2_UNORM = 197
enumerator ISL_FORMAT_R8G8B8A8_UNORM = 199
enumerator ISL_FORMAT_R8G8B8A8_UNORM_SRGB = 200
enumerator ISL_FORMAT_R8G8B8A8_SNORM = 201
enumerator ISL_FORMAT_R8G8B8A8_SINT = 202
enumerator ISL_FORMAT_R8G8B8A8_UINT = 203
enumerator ISL_FORMAT_R16G16_UNORM = 204
enumerator ISL_FORMAT_R16G16_SNORM = 205
enumerator ISL_FORMAT_R16G16_SINT = 206
enumerator ISL_FORMAT_R16G16_UINT = 207
enumerator ISL_FORMAT_R16G16_FLOAT = 208
enumerator ISL_FORMAT_B10G10R10A2_UNORM = 209
enumerator ISL_FORMAT_B10G10R10A2_UNORM_SRGB = 210
enumerator ISL_FORMAT_R11G11B10_FLOAT = 211
enumerator ISL_FORMAT_R10G10B10_FLOAT_A2_UNORM = 213
enumerator ISL_FORMAT_R32_SINT = 214
enumerator ISL_FORMAT_R32_UINT = 215
enumerator ISL_FORMAT_R32_FLOAT = 216
enumerator ISL_FORMAT_R24_UNORM_X8_TYPELESS = 217
enumerator ISL_FORMAT_X24_TYPELESS_G8_UINT = 218
enumerator ISL_FORMAT_L32_UNORM = 221
enumerator ISL_FORMAT_A32_UNORM = 222
enumerator ISL_FORMAT_L16A16_UNORM = 223
enumerator ISL_FORMAT_I24X8_UNORM = 224
enumerator ISL_FORMAT_L24X8_UNORM = 225
enumerator ISL_FORMAT_A24X8_UNORM = 226
enumerator ISL_FORMAT_I32_FLOAT = 227
enumerator ISL_FORMAT_L32_FLOAT = 228
enumerator ISL_FORMAT_A32_FLOAT = 229
enumerator ISL_FORMAT_X8B8_UNORM_G8R8_SNORM = 230
enumerator ISL_FORMAT_A8X8_UNORM_G8R8_SNORM = 231
enumerator ISL_FORMAT_B8X8_UNORM_G8R8_SNORM = 232
enumerator ISL_FORMAT_B8G8R8X8_UNORM = 233
enumerator ISL_FORMAT_B8G8R8X8_UNORM_SRGB = 234
enumerator ISL_FORMAT_R8G8B8X8_UNORM = 235
enumerator ISL_FORMAT_R8G8B8X8_UNORM_SRGB = 236
enumerator ISL_FORMAT_R9G9B9E5_SHAREDEXP = 237
enumerator ISL_FORMAT_B10G10R10X2_UNORM = 238
enumerator ISL_FORMAT_L16A16_FLOAT = 240
enumerator ISL_FORMAT_R32_UNORM = 241
enumerator ISL_FORMAT_R32_SNORM = 242
enumerator ISL_FORMAT_R10G10B10X2_USCALED = 243
enumerator ISL_FORMAT_R8G8B8A8_SSCALED = 244
enumerator ISL_FORMAT_R8G8B8A8_USCALED = 245
enumerator ISL_FORMAT_R16G16_SSCALED = 246
enumerator ISL_FORMAT_R16G16_USCALED = 247
enumerator ISL_FORMAT_R32_SSCALED = 248
enumerator ISL_FORMAT_R32_USCALED = 249
enumerator ISL_FORMAT_B5G6R5_UNORM = 256
enumerator ISL_FORMAT_B5G6R5_UNORM_SRGB = 257
enumerator ISL_FORMAT_B5G5R5A1_UNORM = 258
enumerator ISL_FORMAT_B5G5R5A1_UNORM_SRGB = 259
enumerator ISL_FORMAT_B4G4R4A4_UNORM = 260
enumerator ISL_FORMAT_B4G4R4A4_UNORM_SRGB = 261
enumerator ISL_FORMAT_R8G8_UNORM = 262
enumerator ISL_FORMAT_R8G8_SNORM = 263
enumerator ISL_FORMAT_R8G8_SINT = 264
enumerator ISL_FORMAT_R8G8_UINT = 265
enumerator ISL_FORMAT_R16_UNORM = 266
enumerator ISL_FORMAT_R16_SNORM = 267
enumerator ISL_FORMAT_R16_SINT = 268
enumerator ISL_FORMAT_R16_UINT = 269
enumerator ISL_FORMAT_R16_FLOAT = 270
enumerator ISL_FORMAT_A8P8_UNORM_PALETTE0 = 271
enumerator ISL_FORMAT_A8P8_UNORM_PALETTE1 = 272
enumerator ISL_FORMAT_I16_UNORM = 273
enumerator ISL_FORMAT_L16_UNORM = 274
enumerator ISL_FORMAT_A16_UNORM = 275
enumerator ISL_FORMAT_L8A8_UNORM = 276
enumerator ISL_FORMAT_I16_FLOAT = 277
enumerator ISL_FORMAT_L16_FLOAT = 278
enumerator ISL_FORMAT_A16_FLOAT = 279
enumerator ISL_FORMAT_L8A8_UNORM_SRGB = 280
enumerator ISL_FORMAT_R5G5_SNORM_B6_UNORM = 281
enumerator ISL_FORMAT_B5G5R5X1_UNORM = 282
enumerator ISL_FORMAT_B5G5R5X1_UNORM_SRGB = 283
enumerator ISL_FORMAT_R8G8_SSCALED = 284
enumerator ISL_FORMAT_R8G8_USCALED = 285
enumerator ISL_FORMAT_R16_SSCALED = 286
enumerator ISL_FORMAT_R16_USCALED = 287
enumerator ISL_FORMAT_P8A8_UNORM_PALETTE0 = 290
enumerator ISL_FORMAT_P8A8_UNORM_PALETTE1 = 291
enumerator ISL_FORMAT_A1B5G5R5_UNORM = 292
enumerator ISL_FORMAT_A4B4G4R4_UNORM = 293
enumerator ISL_FORMAT_L8A8_UINT = 294
enumerator ISL_FORMAT_L8A8_SINT = 295
enumerator ISL_FORMAT_R8_UNORM = 320
enumerator ISL_FORMAT_R8_SNORM = 321
enumerator ISL_FORMAT_R8_SINT = 322
enumerator ISL_FORMAT_R8_UINT = 323
enumerator ISL_FORMAT_A8_UNORM = 324
enumerator ISL_FORMAT_I8_UNORM = 325
enumerator ISL_FORMAT_L8_UNORM = 326
enumerator ISL_FORMAT_P4A4_UNORM_PALETTE0 = 327
enumerator ISL_FORMAT_A4P4_UNORM_PALETTE0 = 328
enumerator ISL_FORMAT_R8_SSCALED = 329
enumerator ISL_FORMAT_R8_USCALED = 330
enumerator ISL_FORMAT_P8_UNORM_PALETTE0 = 331
enumerator ISL_FORMAT_L8_UNORM_SRGB = 332
enumerator ISL_FORMAT_P8_UNORM_PALETTE1 = 333
enumerator ISL_FORMAT_P4A4_UNORM_PALETTE1 = 334
enumerator ISL_FORMAT_A4P4_UNORM_PALETTE1 = 335
enumerator ISL_FORMAT_Y8_UNORM = 336
enumerator ISL_FORMAT_L8_UINT = 338
enumerator ISL_FORMAT_L8_SINT = 339
enumerator ISL_FORMAT_I8_UINT = 340
enumerator ISL_FORMAT_I8_SINT = 341
enumerator ISL_FORMAT_DXT1_RGB_SRGB = 384
enumerator ISL_FORMAT_R1_UNORM = 385
enumerator ISL_FORMAT_YCRCB_NORMAL = 386
enumerator ISL_FORMAT_P2_UNORM_PALETTE0 = 388
enumerator ISL_FORMAT_P2_UNORM_PALETTE1 = 389
enumerator ISL_FORMAT_BC1_UNORM = 390
enumerator ISL_FORMAT_BC2_UNORM = 391
enumerator ISL_FORMAT_BC3_UNORM = 392
enumerator ISL_FORMAT_BC4_UNORM = 393
enumerator ISL_FORMAT_BC5_UNORM = 394
enumerator ISL_FORMAT_BC1_UNORM_SRGB = 395
enumerator ISL_FORMAT_BC2_UNORM_SRGB = 396
enumerator ISL_FORMAT_BC3_UNORM_SRGB = 397
enumerator ISL_FORMAT_MONO8 = 398
enumerator ISL_FORMAT_YCRCB_SWAPUV = 399
enumerator ISL_FORMAT_YCRCB_SWAPY = 400
enumerator ISL_FORMAT_DXT1_RGB = 401
enumerator ISL_FORMAT_FXT1 = 402
enumerator ISL_FORMAT_R8G8B8_UNORM = 403
enumerator ISL_FORMAT_R8G8B8_SNORM = 404
enumerator ISL_FORMAT_R8G8B8_SSCALED = 405
enumerator ISL_FORMAT_R8G8B8_USCALED = 406
enumerator ISL_FORMAT_R64G64B64A64_FLOAT = 407
enumerator ISL_FORMAT_R64G64B64_FLOAT = 408
enumerator ISL_FORMAT_BC4_SNORM = 409
enumerator ISL_FORMAT_BC5_SNORM = 410
enumerator ISL_FORMAT_R16G16B16_FLOAT = 411
enumerator ISL_FORMAT_R16G16B16_UNORM = 412
enumerator ISL_FORMAT_R16G16B16_SNORM = 413
enumerator ISL_FORMAT_R16G16B16_SSCALED = 414
enumerator ISL_FORMAT_R16G16B16_USCALED = 415
enumerator ISL_FORMAT_BC6H_SF16 = 417
enumerator ISL_FORMAT_BC7_UNORM = 418
enumerator ISL_FORMAT_BC7_UNORM_SRGB = 419
enumerator ISL_FORMAT_BC6H_UF16 = 420
enumerator ISL_FORMAT_PLANAR_420_8 = 421
enumerator ISL_FORMAT_PLANAR_420_16 = 422
enumerator ISL_FORMAT_R8G8B8_UNORM_SRGB = 424
enumerator ISL_FORMAT_ETC1_RGB8 = 425
enumerator ISL_FORMAT_ETC2_RGB8 = 426
enumerator ISL_FORMAT_EAC_R11 = 427
enumerator ISL_FORMAT_EAC_RG11 = 428
enumerator ISL_FORMAT_EAC_SIGNED_R11 = 429
enumerator ISL_FORMAT_EAC_SIGNED_RG11 = 430
enumerator ISL_FORMAT_ETC2_SRGB8 = 431
enumerator ISL_FORMAT_R16G16B16_UINT = 432
enumerator ISL_FORMAT_R16G16B16_SINT = 433
enumerator ISL_FORMAT_R32_SFIXED = 434
enumerator ISL_FORMAT_R10G10B10A2_SNORM = 435
enumerator ISL_FORMAT_R10G10B10A2_USCALED = 436
enumerator ISL_FORMAT_R10G10B10A2_SSCALED = 437
enumerator ISL_FORMAT_R10G10B10A2_SINT = 438
enumerator ISL_FORMAT_B10G10R10A2_SNORM = 439
enumerator ISL_FORMAT_B10G10R10A2_USCALED = 440
enumerator ISL_FORMAT_B10G10R10A2_SSCALED = 441
enumerator ISL_FORMAT_B10G10R10A2_UINT = 442
enumerator ISL_FORMAT_B10G10R10A2_SINT = 443
enumerator ISL_FORMAT_R64G64B64A64_PASSTHRU = 444
enumerator ISL_FORMAT_R64G64B64_PASSTHRU = 445
enumerator ISL_FORMAT_ETC2_RGB8_PTA = 448
enumerator ISL_FORMAT_ETC2_SRGB8_PTA = 449
enumerator ISL_FORMAT_ETC2_EAC_RGBA8 = 450
enumerator ISL_FORMAT_ETC2_EAC_SRGB8_A8 = 451
enumerator ISL_FORMAT_R8G8B8_UINT = 456
enumerator ISL_FORMAT_R8G8B8_SINT = 457
enumerator ISL_FORMAT_RAW = 511
enumerator ISL_FORMAT_ASTC_LDR_2D_4X4_U8SRGB = 512
enumerator ISL_FORMAT_ASTC_LDR_2D_5X4_U8SRGB = 520
enumerator ISL_FORMAT_ASTC_LDR_2D_5X5_U8SRGB = 521
enumerator ISL_FORMAT_ASTC_LDR_2D_6X5_U8SRGB = 529
enumerator ISL_FORMAT_ASTC_LDR_2D_6X6_U8SRGB = 530
enumerator ISL_FORMAT_ASTC_LDR_2D_8X5_U8SRGB = 545
enumerator ISL_FORMAT_ASTC_LDR_2D_8X6_U8SRGB = 546
enumerator ISL_FORMAT_ASTC_LDR_2D_8X8_U8SRGB = 548
enumerator ISL_FORMAT_ASTC_LDR_2D_10X5_U8SRGB = 561
enumerator ISL_FORMAT_ASTC_LDR_2D_10X6_U8SRGB = 562
enumerator ISL_FORMAT_ASTC_LDR_2D_10X8_U8SRGB = 564
enumerator ISL_FORMAT_ASTC_LDR_2D_10X10_U8SRGB = 566
enumerator ISL_FORMAT_ASTC_LDR_2D_12X10_U8SRGB = 574
enumerator ISL_FORMAT_ASTC_LDR_2D_12X12_U8SRGB = 575
enumerator ISL_FORMAT_ASTC_LDR_2D_4X4_FLT16 = 576
enumerator ISL_FORMAT_ASTC_LDR_2D_5X4_FLT16 = 584
enumerator ISL_FORMAT_ASTC_LDR_2D_5X5_FLT16 = 585
enumerator ISL_FORMAT_ASTC_LDR_2D_6X5_FLT16 = 593
enumerator ISL_FORMAT_ASTC_LDR_2D_6X6_FLT16 = 594
enumerator ISL_FORMAT_ASTC_LDR_2D_8X5_FLT16 = 609
enumerator ISL_FORMAT_ASTC_LDR_2D_8X6_FLT16 = 610
enumerator ISL_FORMAT_ASTC_LDR_2D_8X8_FLT16 = 612
enumerator ISL_FORMAT_ASTC_LDR_2D_10X5_FLT16 = 625
enumerator ISL_FORMAT_ASTC_LDR_2D_10X6_FLT16 = 626
enumerator ISL_FORMAT_ASTC_LDR_2D_10X8_FLT16 = 628
enumerator ISL_FORMAT_ASTC_LDR_2D_10X10_FLT16 = 630
enumerator ISL_FORMAT_ASTC_LDR_2D_12X10_FLT16 = 638
enumerator ISL_FORMAT_ASTC_LDR_2D_12X12_FLT16 = 639
enumerator ISL_FORMAT_ASTC_HDR_2D_4X4_FLT16 = 832
enumerator ISL_FORMAT_ASTC_HDR_2D_5X4_FLT16 = 840
enumerator ISL_FORMAT_ASTC_HDR_2D_5X5_FLT16 = 841
enumerator ISL_FORMAT_ASTC_HDR_2D_6X5_FLT16 = 849
enumerator ISL_FORMAT_ASTC_HDR_2D_6X6_FLT16 = 850
enumerator ISL_FORMAT_ASTC_HDR_2D_8X5_FLT16 = 865
enumerator ISL_FORMAT_ASTC_HDR_2D_8X6_FLT16 = 866
enumerator ISL_FORMAT_ASTC_HDR_2D_8X8_FLT16 = 868
enumerator ISL_FORMAT_ASTC_HDR_2D_10X5_FLT16 = 881
enumerator ISL_FORMAT_ASTC_HDR_2D_10X6_FLT16 = 882
enumerator ISL_FORMAT_ASTC_HDR_2D_10X8_FLT16 = 884
enumerator ISL_FORMAT_ASTC_HDR_2D_10X10_FLT16 = 886
enumerator ISL_FORMAT_ASTC_HDR_2D_12X10_FLT16 = 894
enumerator ISL_FORMAT_ASTC_HDR_2D_12X12_FLT16 = 895
enumerator ISL_FORMAT_PLANAR_420_10
enumerator ISL_FORMAT_PLANAR_420_12
enumerator ISL_FORMAT_HIZ
enumerator ISL_FORMAT_GFX125_HIZ
enumerator ISL_FORMAT_MCS_2X
enumerator ISL_FORMAT_MCS_4X
enumerator ISL_FORMAT_MCS_8X
enumerator ISL_FORMAT_MCS_16X
enumerator ISL_FORMAT_GFX7_CCS_32BPP_X
enumerator ISL_FORMAT_GFX7_CCS_64BPP_X
enumerator ISL_FORMAT_GFX7_CCS_128BPP_X
enumerator ISL_FORMAT_GFX7_CCS_32BPP_Y
enumerator ISL_FORMAT_GFX7_CCS_64BPP_Y
enumerator ISL_FORMAT_GFX7_CCS_128BPP_Y
enumerator ISL_FORMAT_GFX9_CCS_32BPP
enumerator ISL_FORMAT_GFX9_CCS_64BPP
enumerator ISL_FORMAT_GFX9_CCS_128BPP
enumerator ISL_FORMAT_GFX12_CCS_8BPP_Y0
enumerator ISL_FORMAT_GFX12_CCS_16BPP_Y0
enumerator ISL_FORMAT_GFX12_CCS_32BPP_Y0
enumerator ISL_FORMAT_GFX12_CCS_64BPP_Y0
enumerator ISL_FORMAT_GFX12_CCS_128BPP_Y0
enumerator ISL_NUM_FORMATS