*/
+#include "errors.h"
#include "imports.h"
#include "formats.h"
#include "macros.h"
/**
* Information about texture formats.
*/
-struct gl_format_info
+struct mesa_format_info
{
mesa_format Name;
*/
GLenum DataType;
- GLubyte RedBits;
- GLubyte GreenBits;
- GLubyte BlueBits;
- GLubyte AlphaBits;
- GLubyte LuminanceBits;
- GLubyte IntensityBits;
- GLubyte DepthBits;
- GLubyte StencilBits;
+ uint8_t RedBits;
+ uint8_t GreenBits;
+ uint8_t BlueBits;
+ uint8_t AlphaBits;
+ uint8_t LuminanceBits;
+ uint8_t IntensityBits;
+ uint8_t DepthBits;
+ uint8_t StencilBits;
bool IsSRGBFormat;
/**
- * To describe compressed formats. If not compressed, Width=Height=1.
+ * To describe compressed formats. If not compressed, Width=Height=Depth=1.
*/
- GLubyte BlockWidth, BlockHeight;
- GLubyte BytesPerBlock;
+ uint8_t BlockWidth, BlockHeight, BlockDepth;
+ uint8_t BytesPerBlock;
uint8_t Swizzle[4];
mesa_array_format ArrayFormat;
#include "format_info.h"
-static const struct gl_format_info *
+static const struct mesa_format_info *
_mesa_get_format_info(mesa_format format)
{
- const struct gl_format_info *info = &format_info[format];
+ const struct mesa_format_info *info = &format_info[format];
STATIC_ASSERT(ARRAY_SIZE(format_info) == MESA_FORMAT_COUNT);
assert(info->Name == format);
return info;
const char *
_mesa_get_format_name(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->StrName;
}
* Normally, a block is 1x1 (a single pixel). But for compressed formats
* a block may be 4x4 or 8x4, etc.
*
- * Note: not GLuint, so as not to coerce math to unsigned. cf. fdo #37351
+ * Note: return is signed, so as not to coerce math to unsigned. cf. fdo #37351
*/
-GLint
+int
_mesa_get_format_bytes(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ if (_mesa_format_is_mesa_array_format(format)) {
+ return _mesa_array_format_get_type_size(format) *
+ _mesa_array_format_get_num_channels(format);
+ }
+
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
assert(info->BytesPerBlock);
assert(info->BytesPerBlock <= MAX_PIXEL_BYTES ||
_mesa_is_format_compressed(format));
GLint
_mesa_get_format_bits(mesa_format format, GLenum pname)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
switch (pname) {
case GL_RED_BITS:
case GL_TEXTURE_RED_SIZE:
case GL_RENDERBUFFER_RED_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+ case GL_INTERNALFORMAT_RED_SIZE:
return info->RedBits;
case GL_GREEN_BITS:
case GL_TEXTURE_GREEN_SIZE:
case GL_RENDERBUFFER_GREEN_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+ case GL_INTERNALFORMAT_GREEN_SIZE:
return info->GreenBits;
case GL_BLUE_BITS:
case GL_TEXTURE_BLUE_SIZE:
case GL_RENDERBUFFER_BLUE_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+ case GL_INTERNALFORMAT_BLUE_SIZE:
return info->BlueBits;
case GL_ALPHA_BITS:
case GL_TEXTURE_ALPHA_SIZE:
case GL_RENDERBUFFER_ALPHA_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+ case GL_INTERNALFORMAT_ALPHA_SIZE:
return info->AlphaBits;
case GL_TEXTURE_INTENSITY_SIZE:
return info->IntensityBits;
case GL_TEXTURE_DEPTH_SIZE_ARB:
case GL_RENDERBUFFER_DEPTH_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+ case GL_INTERNALFORMAT_DEPTH_SIZE:
return info->DepthBits;
case GL_STENCIL_BITS:
case GL_TEXTURE_STENCIL_SIZE_EXT:
case GL_RENDERBUFFER_STENCIL_SIZE_EXT:
case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+ case GL_INTERNALFORMAT_STENCIL_SIZE:
return info->StencilBits;
default:
_mesa_problem(NULL, "bad pname in _mesa_get_format_bits()");
}
-GLuint
+unsigned int
_mesa_get_format_max_bits(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
- GLuint max = MAX2(info->RedBits, info->GreenBits);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ unsigned int max = MAX2(info->RedBits, info->GreenBits);
max = MAX2(max, info->BlueBits);
max = MAX2(max, info->AlphaBits);
max = MAX2(max, info->LuminanceBits);
/**
* Return the layout type of the given format.
- * The return value will be one of:
- * MESA_FORMAT_LAYOUT_ARRAY
- * MESA_FORMAT_LAYOUT_PACKED
- * MESA_FORMAT_LAYOUT_S3TC
- * MESA_FORMAT_LAYOUT_RGTC
- * MESA_FORMAT_LAYOUT_FXT1
- * MESA_FORMAT_LAYOUT_ETC1
- * MESA_FORMAT_LAYOUT_ETC2
- * MESA_FORMAT_LAYOUT_BPTC
- * MESA_FORMAT_LAYOUT_ASTC
- * MESA_FORMAT_LAYOUT_OTHER
*/
extern enum mesa_format_layout
_mesa_get_format_layout(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->Layout;
}
GLenum
_mesa_get_format_datatype(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->DataType;
}
uint8_t swizzle[4];
int num_channels;
+ switch (_mesa_array_format_get_base_format(format)) {
+ case MESA_ARRAY_FORMAT_BASE_FORMAT_DEPTH:
+ return GL_DEPTH_COMPONENT;
+ case MESA_ARRAY_FORMAT_BASE_FORMAT_STENCIL:
+ return GL_STENCIL_INDEX;
+ case MESA_ARRAY_FORMAT_BASE_FORMAT_RGBA_VARIANTS:
+ break;
+ }
+
_mesa_array_format_get_swizzle(format, swizzle);
num_channels = _mesa_array_format_get_num_channels(format);
_mesa_get_format_base_format(uint32_t format)
{
if (!_mesa_format_is_mesa_array_format(format)) {
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->BaseFormat;
} else {
return get_base_format_for_array_format(format);
* \param bh returns block height in pixels
*/
void
-_mesa_get_format_block_size(mesa_format format, GLuint *bw, GLuint *bh)
+_mesa_get_format_block_size(mesa_format format,
+ unsigned int *bw, unsigned int *bh)
+{
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ /* Use _mesa_get_format_block_size_3d() for 3D blocks. */
+ assert(info->BlockDepth == 1);
+
+ *bw = info->BlockWidth;
+ *bh = info->BlockHeight;
+}
+
+
+/**
+ * Return the block size (in pixels) for the given format. Normally
+ * the block size is 1x1x1. But compressed formats will have block
+ * sizes of 4x4x4, 3x3x3 pixels, etc.
+ * \param bw returns block width in pixels
+ * \param bh returns block height in pixels
+ * \param bd returns block depth in pixels
+ */
+void
+_mesa_get_format_block_size_3d(mesa_format format,
+ unsigned int *bw,
+ unsigned int *bh,
+ unsigned int *bd)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
*bw = info->BlockWidth;
*bh = info->BlockHeight;
+ *bd = info->BlockDepth;
}
void
_mesa_get_format_swizzle(mesa_format format, uint8_t swizzle_out[4])
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
memcpy(swizzle_out, info->Swizzle, sizeof(info->Swizzle));
}
uint32_t
_mesa_format_to_array_format(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
- if (info->ArrayFormat && !_mesa_little_endian() &&
- info->Layout == MESA_FORMAT_LAYOUT_PACKED)
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+#if UTIL_ARCH_BIG_ENDIAN
+ if (info->ArrayFormat && info->Layout == MESA_FORMAT_LAYOUT_PACKED)
return _mesa_array_format_flip_channels(info->ArrayFormat);
else
+#endif
return info->ArrayFormat;
}
static struct hash_table *format_array_format_table;
static once_flag format_array_format_table_exists = ONCE_FLAG_INIT;
+static void
+format_array_format_table_destroy(void)
+{
+ _mesa_hash_table_destroy(format_array_format_table, NULL);
+}
+
static bool
array_formats_equal(const void *a, const void *b)
{
static void
format_array_format_table_init(void)
{
- const struct gl_format_info *info;
+ const struct mesa_format_info *info;
mesa_array_format array_format;
unsigned f;
if (!info->ArrayFormat)
continue;
- if (_mesa_little_endian()) {
+#if UTIL_ARCH_LITTLE_ENDIAN
array_format = info->ArrayFormat;
- } else {
+#else
array_format = _mesa_array_format_flip_channels(info->ArrayFormat);
- }
+#endif
/* This can happen and does for some of the BGR formats. Let's take
* the first one in the list.
(void *)(intptr_t)array_format,
(void *)(intptr_t)f);
}
+
+ atexit(format_array_format_table_destroy);
}
mesa_format
}
/** Is the given format a compressed format? */
-GLboolean
+bool
_mesa_is_format_compressed(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->BlockWidth > 1 || info->BlockHeight > 1;
}
/**
* Determine if the given format represents a packed depth/stencil buffer.
*/
-GLboolean
+bool
_mesa_is_format_packed_depth_stencil(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return info->BaseFormat == GL_DEPTH_STENCIL;
}
/**
* Is the given format a signed/unsigned integer color format?
*/
-GLboolean
+bool
_mesa_is_format_integer_color(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT) &&
info->BaseFormat != GL_DEPTH_COMPONENT &&
info->BaseFormat != GL_DEPTH_STENCIL &&
/**
* Is the given format an unsigned integer format?
*/
-GLboolean
+bool
_mesa_is_format_unsigned(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return _mesa_is_type_unsigned(info->DataType);
}
/**
* Does the given format store signed values?
*/
-GLboolean
+bool
_mesa_is_format_signed(mesa_format format)
{
if (format == MESA_FORMAT_R11G11B10_FLOAT ||
format == MESA_FORMAT_R9G9B9E5_FLOAT) {
/* these packed float formats only store unsigned values */
- return GL_FALSE;
+ return false;
}
else {
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return (info->DataType == GL_SIGNED_NORMALIZED ||
info->DataType == GL_INT ||
info->DataType == GL_FLOAT);
/**
* Is the given format an integer format?
*/
-GLboolean
+bool
_mesa_is_format_integer(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return (info->DataType == GL_INT || info->DataType == GL_UNSIGNED_INT);
}
/**
* Return true if the given format is a color format.
*/
-GLenum
+bool
_mesa_is_format_color_format(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
switch (info->BaseFormat) {
case GL_DEPTH_COMPONENT:
case GL_STENCIL_INDEX:
}
}
-
-/**
- * Return color encoding for given format.
- * \return GL_LINEAR or GL_SRGB
- */
-GLenum
-_mesa_get_format_color_encoding(mesa_format format)
+bool
+_mesa_is_format_srgb(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
- return info->IsSRGBFormat ? GL_SRGB : GL_LINEAR;
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ return info->IsSRGBFormat;
}
-
/**
* Return TRUE if format is an ETC2 compressed format specified
* by GL_ARB_ES3_compatibility.
case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
- return GL_TRUE;
+ return true;
default:
- return GL_FALSE;
+ return false;
}
}
/**
- * For an sRGB format, return the corresponding linear color space format.
- * For non-sRGB formats, return the format as-is.
+ * Return TRUE if format is an ASTC 2D compressed format.
*/
-mesa_format
-_mesa_get_srgb_format_linear(mesa_format format)
+bool
+_mesa_is_format_astc_2d(mesa_format format)
{
switch (format) {
- case MESA_FORMAT_BGR_SRGB8:
- format = MESA_FORMAT_BGR_UNORM8;
- break;
- case MESA_FORMAT_A8B8G8R8_SRGB:
- format = MESA_FORMAT_A8B8G8R8_UNORM;
- break;
- case MESA_FORMAT_B8G8R8A8_SRGB:
- format = MESA_FORMAT_B8G8R8A8_UNORM;
- break;
- case MESA_FORMAT_A8R8G8B8_SRGB:
- format = MESA_FORMAT_A8R8G8B8_UNORM;
- break;
- case MESA_FORMAT_R8G8B8A8_SRGB:
- format = MESA_FORMAT_R8G8B8A8_UNORM;
- break;
- case MESA_FORMAT_L_SRGB8:
- format = MESA_FORMAT_L_UNORM8;
- break;
- case MESA_FORMAT_L8A8_SRGB:
- format = MESA_FORMAT_L8A8_UNORM;
- break;
- case MESA_FORMAT_A8L8_SRGB:
- format = MESA_FORMAT_A8L8_UNORM;
- break;
- case MESA_FORMAT_SRGB_DXT1:
- format = MESA_FORMAT_RGB_DXT1;
- break;
- case MESA_FORMAT_SRGBA_DXT1:
- format = MESA_FORMAT_RGBA_DXT1;
- break;
- case MESA_FORMAT_SRGBA_DXT3:
- format = MESA_FORMAT_RGBA_DXT3;
- break;
- case MESA_FORMAT_SRGBA_DXT5:
- format = MESA_FORMAT_RGBA_DXT5;
- break;
- case MESA_FORMAT_R8G8B8X8_SRGB:
- format = MESA_FORMAT_R8G8B8X8_UNORM;
- break;
- case MESA_FORMAT_X8B8G8R8_SRGB:
- format = MESA_FORMAT_X8B8G8R8_UNORM;
- break;
- case MESA_FORMAT_ETC2_SRGB8:
- format = MESA_FORMAT_ETC2_RGB8;
- break;
- case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
- format = MESA_FORMAT_ETC2_RGBA8_EAC;
- break;
- case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
- format = MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
- break;
- case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
- format = MESA_FORMAT_BPTC_RGBA_UNORM;
- break;
+ case MESA_FORMAT_RGBA_ASTC_4x4:
+ case MESA_FORMAT_RGBA_ASTC_5x4:
+ case MESA_FORMAT_RGBA_ASTC_5x5:
+ case MESA_FORMAT_RGBA_ASTC_6x5:
+ case MESA_FORMAT_RGBA_ASTC_6x6:
+ case MESA_FORMAT_RGBA_ASTC_8x5:
+ case MESA_FORMAT_RGBA_ASTC_8x6:
+ case MESA_FORMAT_RGBA_ASTC_8x8:
+ case MESA_FORMAT_RGBA_ASTC_10x5:
+ case MESA_FORMAT_RGBA_ASTC_10x6:
+ case MESA_FORMAT_RGBA_ASTC_10x8:
+ case MESA_FORMAT_RGBA_ASTC_10x10:
+ case MESA_FORMAT_RGBA_ASTC_12x10:
+ case MESA_FORMAT_RGBA_ASTC_12x12:
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4:
- format = MESA_FORMAT_RGBA_ASTC_4x4;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4:
- format = MESA_FORMAT_RGBA_ASTC_5x4;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5:
- format = MESA_FORMAT_RGBA_ASTC_5x5;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5:
- format = MESA_FORMAT_RGBA_ASTC_6x5;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6:
- format = MESA_FORMAT_RGBA_ASTC_6x6;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5:
- format = MESA_FORMAT_RGBA_ASTC_8x5;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6:
- format = MESA_FORMAT_RGBA_ASTC_8x6;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8:
- format = MESA_FORMAT_RGBA_ASTC_8x8;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5:
- format = MESA_FORMAT_RGBA_ASTC_10x5;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6:
- format = MESA_FORMAT_RGBA_ASTC_10x6;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8:
- format = MESA_FORMAT_RGBA_ASTC_10x8;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10:
- format = MESA_FORMAT_RGBA_ASTC_10x10;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10:
- format = MESA_FORMAT_RGBA_ASTC_12x10;
- break;
case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12:
- format = MESA_FORMAT_RGBA_ASTC_12x12;
- break;
- case MESA_FORMAT_B8G8R8X8_SRGB:
- format = MESA_FORMAT_B8G8R8X8_UNORM;
- break;
- case MESA_FORMAT_X8R8G8B8_SRGB:
- format = MESA_FORMAT_X8R8G8B8_UNORM;
- break;
+ return true;
default:
- break;
+ return false;
}
- return format;
}
case MESA_FORMAT_R_RGTC1_SNORM:
return MESA_FORMAT_R_SNORM8;
case MESA_FORMAT_RG_RGTC2_UNORM:
- return MESA_FORMAT_R8G8_UNORM;
+ return MESA_FORMAT_RG_UNORM8;
case MESA_FORMAT_RG_RGTC2_SNORM:
- return MESA_FORMAT_R8G8_SNORM;
+ return MESA_FORMAT_RG_SNORM8;
case MESA_FORMAT_L_LATC1_UNORM:
return MESA_FORMAT_L_UNORM8;
case MESA_FORMAT_L_LATC1_SNORM:
return MESA_FORMAT_L_SNORM8;
case MESA_FORMAT_LA_LATC2_UNORM:
- return MESA_FORMAT_L8A8_UNORM;
+ return MESA_FORMAT_LA_UNORM8;
case MESA_FORMAT_LA_LATC2_SNORM:
- return MESA_FORMAT_L8A8_SNORM;
+ return MESA_FORMAT_LA_SNORM8;
case MESA_FORMAT_ETC1_RGB8:
case MESA_FORMAT_ETC2_RGB8:
case MESA_FORMAT_ETC2_SRGB8:
+ case MESA_FORMAT_ATC_RGB:
return MESA_FORMAT_BGR_UNORM8;
case MESA_FORMAT_ETC2_RGBA8_EAC:
case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
+ case MESA_FORMAT_ATC_RGBA_EXPLICIT:
+ case MESA_FORMAT_ATC_RGBA_INTERPOLATED:
return MESA_FORMAT_A8B8G8R8_UNORM;
case MESA_FORMAT_ETC2_R11_EAC:
case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
return MESA_FORMAT_R_UNORM16;
case MESA_FORMAT_ETC2_RG11_EAC:
case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
- return MESA_FORMAT_R16G16_UNORM;
+ return MESA_FORMAT_RG_UNORM16;
case MESA_FORMAT_BPTC_RGBA_UNORM:
case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
return MESA_FORMAT_A8B8G8R8_UNORM;
case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
return MESA_FORMAT_RGB_FLOAT32;
default:
-#ifdef DEBUG
assert(!_mesa_is_format_compressed(format));
-#endif
return format;
}
}
-GLuint
+unsigned int
_mesa_format_num_components(mesa_format format)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
return ((info->RedBits > 0) +
(info->GreenBits > 0) +
(info->BlueBits > 0) +
bool
_mesa_format_has_color_component(mesa_format format, int component)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
assert(info->BaseFormat != GL_DEPTH_COMPONENT &&
info->BaseFormat != GL_DEPTH_STENCIL &&
* Return number of bytes needed to store an image of the given size
* in the given format.
*/
-GLuint
-_mesa_format_image_size(mesa_format format, GLsizei width,
- GLsizei height, GLsizei depth)
+uint32_t
+_mesa_format_image_size(mesa_format format, int width,
+ int height, int depth)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ uint32_t sz;
/* Strictly speaking, a conditional isn't needed here */
- if (info->BlockWidth > 1 || info->BlockHeight > 1) {
+ if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) {
/* compressed format (2D only for now) */
- const GLuint bw = info->BlockWidth, bh = info->BlockHeight;
- const GLuint wblocks = (width + bw - 1) / bw;
- const GLuint hblocks = (height + bh - 1) / bh;
- const GLuint sz = wblocks * hblocks * info->BytesPerBlock;
- return sz * depth;
- }
- else {
+ const uint32_t bw = info->BlockWidth;
+ const uint32_t bh = info->BlockHeight;
+ const uint32_t bd = info->BlockDepth;
+ const uint32_t wblocks = (width + bw - 1) / bw;
+ const uint32_t hblocks = (height + bh - 1) / bh;
+ const uint32_t dblocks = (depth + bd - 1) / bd;
+ sz = wblocks * hblocks * dblocks * info->BytesPerBlock;
+ } else
/* non-compressed */
- const GLuint sz = width * height * depth * info->BytesPerBlock;
- return sz;
- }
+ sz = width * height * depth * info->BytesPerBlock;
+
+ return sz;
}
* accommodate very large textures.
*/
uint64_t
-_mesa_format_image_size64(mesa_format format, GLsizei width,
- GLsizei height, GLsizei depth)
+_mesa_format_image_size64(mesa_format format, int width,
+ int height, int depth)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ uint64_t sz;
/* Strictly speaking, a conditional isn't needed here */
- if (info->BlockWidth > 1 || info->BlockHeight > 1) {
+ if (info->BlockWidth > 1 || info->BlockHeight > 1 || info->BlockDepth > 1) {
/* compressed format (2D only for now) */
- const uint64_t bw = info->BlockWidth, bh = info->BlockHeight;
+ const uint64_t bw = info->BlockWidth;
+ const uint64_t bh = info->BlockHeight;
+ const uint64_t bd = info->BlockDepth;
const uint64_t wblocks = (width + bw - 1) / bw;
const uint64_t hblocks = (height + bh - 1) / bh;
- const uint64_t sz = wblocks * hblocks * info->BytesPerBlock;
- return sz * depth;
- }
- else {
+ const uint64_t dblocks = (depth + bd - 1) / bd;
+ sz = wblocks * hblocks * dblocks * info->BytesPerBlock;
+ } else
/* non-compressed */
- const uint64_t sz = ((uint64_t) width *
- (uint64_t) height *
- (uint64_t) depth *
- info->BytesPerBlock);
- return sz;
- }
+ sz = ((uint64_t) width * (uint64_t) height *
+ (uint64_t) depth * info->BytesPerBlock);
+
+ return sz;
}
-GLint
-_mesa_format_row_stride(mesa_format format, GLsizei width)
+int32_t
+_mesa_format_row_stride(mesa_format format, int width)
{
- const struct gl_format_info *info = _mesa_get_format_info(format);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
/* Strictly speaking, a conditional isn't needed here */
if (info->BlockWidth > 1 || info->BlockHeight > 1) {
/* compressed format */
- const GLuint bw = info->BlockWidth;
- const GLuint wblocks = (width + bw - 1) / bw;
- const GLint stride = wblocks * info->BytesPerBlock;
+ const uint32_t bw = info->BlockWidth;
+ const uint32_t wblocks = (width + bw - 1) / bw;
+ const int32_t stride = wblocks * info->BytesPerBlock;
return stride;
}
else {
- const GLint stride = width * info->BytesPerBlock;
+ const int32_t stride = width * info->BytesPerBlock;
return stride;
}
}
case MESA_FORMAT_R8G8B8X8_UNORM:
case MESA_FORMAT_B8G8R8X8_UNORM:
case MESA_FORMAT_X8R8G8B8_UNORM:
+ case MESA_FORMAT_A8B8G8R8_UINT:
+ case MESA_FORMAT_R8G8B8A8_UINT:
+ case MESA_FORMAT_B8G8R8A8_UINT:
+ case MESA_FORMAT_A8R8G8B8_UINT:
*datatype = GL_UNSIGNED_BYTE;
*comps = 4;
return;
return;
case MESA_FORMAT_B5G6R5_UNORM:
case MESA_FORMAT_R5G6B5_UNORM:
+ case MESA_FORMAT_B5G6R5_UINT:
+ case MESA_FORMAT_R5G6B5_UINT:
*datatype = GL_UNSIGNED_SHORT_5_6_5;
*comps = 3;
return;
case MESA_FORMAT_B4G4R4A4_UNORM:
case MESA_FORMAT_A4R4G4B4_UNORM:
case MESA_FORMAT_B4G4R4X4_UNORM:
+ case MESA_FORMAT_B4G4R4A4_UINT:
+ case MESA_FORMAT_A4R4G4B4_UINT:
*datatype = GL_UNSIGNED_SHORT_4_4_4_4;
*comps = 4;
return;
case MESA_FORMAT_B5G5R5A1_UNORM:
case MESA_FORMAT_A1R5G5B5_UNORM:
case MESA_FORMAT_B5G5R5X1_UNORM:
+ case MESA_FORMAT_B5G5R5A1_UINT:
+ case MESA_FORMAT_A1R5G5B5_UINT:
*datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
*comps = 4;
return;
return;
case MESA_FORMAT_A1B5G5R5_UNORM:
+ case MESA_FORMAT_A1B5G5R5_UINT:
+ case MESA_FORMAT_X1B5G5R5_UNORM:
*datatype = GL_UNSIGNED_SHORT_5_5_5_1;
*comps = 4;
return;
*comps = 2;
return;
- case MESA_FORMAT_L8A8_UNORM:
- case MESA_FORMAT_A8L8_UNORM:
- case MESA_FORMAT_R8G8_UNORM:
- case MESA_FORMAT_G8R8_UNORM:
+ case MESA_FORMAT_LA_UNORM8:
+ case MESA_FORMAT_RG_UNORM8:
*datatype = GL_UNSIGNED_BYTE;
*comps = 2;
return;
- case MESA_FORMAT_L16A16_UNORM:
- case MESA_FORMAT_A16L16_UNORM:
- case MESA_FORMAT_R16G16_UNORM:
- case MESA_FORMAT_G16R16_UNORM:
+ case MESA_FORMAT_LA_UNORM16:
+ case MESA_FORMAT_RG_UNORM16:
*datatype = GL_UNSIGNED_SHORT;
*comps = 2;
return;
return;
case MESA_FORMAT_R3G3B2_UNORM:
+ case MESA_FORMAT_R3G3B2_UINT:
*datatype = GL_UNSIGNED_BYTE_2_3_3_REV;
*comps = 3;
return;
case MESA_FORMAT_A4B4G4R4_UNORM:
+ case MESA_FORMAT_A4B4G4R4_UINT:
*datatype = GL_UNSIGNED_SHORT_4_4_4_4;
*comps = 4;
return;
case MESA_FORMAT_R4G4B4A4_UNORM:
+ case MESA_FORMAT_R4G4B4A4_UINT:
*datatype = GL_UNSIGNED_SHORT_4_4_4_4;
*comps = 4;
return;
case MESA_FORMAT_R5G5B5A1_UNORM:
+ case MESA_FORMAT_R5G5B5A1_UINT:
*datatype = GL_UNSIGNED_SHORT_1_5_5_5_REV;
*comps = 4;
return;
return;
case MESA_FORMAT_B2G3R3_UNORM:
+ case MESA_FORMAT_B2G3R3_UINT:
*datatype = GL_UNSIGNED_BYTE_3_3_2;
*comps = 3;
return;
*datatype = GL_BYTE;
*comps = 1;
return;
- case MESA_FORMAT_R8G8_SNORM:
- case MESA_FORMAT_L8A8_SNORM:
- case MESA_FORMAT_A8L8_SNORM:
+ case MESA_FORMAT_RG_SNORM8:
+ case MESA_FORMAT_LA_SNORM8:
*datatype = GL_BYTE;
*comps = 2;
return;
*datatype = GL_SHORT;
*comps = 1;
return;
- case MESA_FORMAT_R16G16_SNORM:
+ case MESA_FORMAT_RG_SNORM16:
case MESA_FORMAT_LA_SNORM16:
*datatype = GL_SHORT;
*comps = 2;
*comps = 4;
return;
case MESA_FORMAT_L_SRGB8:
+ case MESA_FORMAT_R_SRGB8:
*datatype = GL_UNSIGNED_BYTE;
*comps = 1;
return;
- case MESA_FORMAT_L8A8_SRGB:
- case MESA_FORMAT_A8L8_SRGB:
+ case MESA_FORMAT_LA_SRGB8:
*datatype = GL_UNSIGNED_BYTE;
*comps = 2;
return;
*comps = 4;
return;
- case MESA_FORMAT_G8R8_SNORM:
- *datatype = GL_BYTE;
- *comps = 2;
- return;
-
- case MESA_FORMAT_G16R16_SNORM:
- *datatype = GL_SHORT;
- *comps = 2;
- return;
-
case MESA_FORMAT_B8G8R8X8_SRGB:
case MESA_FORMAT_X8R8G8B8_SRGB:
*datatype = GL_UNSIGNED_BYTE;
* \param swapBytes typically the current pixel pack/unpack byteswap state
* \param[out] error GL_NO_ERROR if format is an expected input.
* GL_INVALID_ENUM if format is an unexpected input.
- * \return GL_TRUE if the formats match, GL_FALSE otherwise.
+ * \return true if the formats match, false otherwise.
*/
-GLboolean
-_mesa_format_matches_format_and_type(mesa_format mesa_format,
+bool
+_mesa_format_matches_format_and_type(mesa_format mformat,
GLenum format, GLenum type,
- GLboolean swapBytes, GLenum *error)
+ bool swapBytes, GLenum *error)
{
- const GLboolean littleEndian = _mesa_little_endian();
if (error)
*error = GL_NO_ERROR;
- /* Note: When reading a GL format/type combination, the format lists channel
- * assignments from most significant channel in the type to least
- * significant. A type with _REV indicates that the assignments are
- * swapped, so they are listed from least significant to most significant.
- *
- * Compressed formats will fall through and return GL_FALSE.
- *
- * For sanity, please keep this switch statement ordered the same as the
- * enums in formats.h.
- */
-
- switch (mesa_format) {
-
- case MESA_FORMAT_NONE:
- case MESA_FORMAT_COUNT:
- return GL_FALSE;
-
- case MESA_FORMAT_A8B8G8R8_UNORM:
- case MESA_FORMAT_A8B8G8R8_SRGB:
- if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV
- && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8
- && swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_R8G8B8A8_UNORM:
- case MESA_FORMAT_R8G8B8A8_SRGB:
- if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
- !swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 &&
- !swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
- swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_B8G8R8A8_UNORM:
- case MESA_FORMAT_B8G8R8A8_SRGB:
- if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
- !swapBytes)
- return GL_TRUE;
-
- if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
- return GL_TRUE;
-
- if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_A8R8G8B8_UNORM:
- case MESA_FORMAT_A8R8G8B8_SRGB:
- if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
- swapBytes)
- return GL_TRUE;
-
- if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_X8B8G8R8_UNORM:
- case MESA_FORMAT_R8G8B8X8_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_B8G8R8X8_UNORM:
- case MESA_FORMAT_X8R8G8B8_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_BGR_UNORM8:
- case MESA_FORMAT_BGR_SRGB8:
- return format == GL_BGR && type == GL_UNSIGNED_BYTE && littleEndian;
-
- case MESA_FORMAT_RGB_UNORM8:
- return format == GL_RGB && type == GL_UNSIGNED_BYTE && littleEndian;
-
- case MESA_FORMAT_B5G6R5_UNORM:
- return ((format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) ||
- (format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5_REV)) &&
- !swapBytes;
-
- case MESA_FORMAT_R5G6B5_UNORM:
- return ((format == GL_BGR && type == GL_UNSIGNED_SHORT_5_6_5) ||
- (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5_REV)) &&
- !swapBytes;
-
- case MESA_FORMAT_B4G4R4A4_UNORM:
- return format == GL_BGRA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV &&
- !swapBytes;
-
- case MESA_FORMAT_A4R4G4B4_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_A1B5G5R5_UNORM:
- return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
- !swapBytes;
-
- case MESA_FORMAT_B5G5R5A1_UNORM:
- return format == GL_BGRA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV &&
- !swapBytes;
-
- case MESA_FORMAT_A1R5G5B5_UNORM:
- return format == GL_BGRA && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
- !swapBytes;
-
- case MESA_FORMAT_L4A4_UNORM:
- return GL_FALSE;
- case MESA_FORMAT_L8A8_UNORM:
- case MESA_FORMAT_L8A8_SRGB:
- return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE && littleEndian;
- case MESA_FORMAT_A8L8_UNORM:
- case MESA_FORMAT_A8L8_SRGB:
- return GL_FALSE;
-
- case MESA_FORMAT_L16A16_UNORM:
- return format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_SHORT && littleEndian && !swapBytes;
- case MESA_FORMAT_A16L16_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_B2G3R3_UNORM:
- return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2;
-
- case MESA_FORMAT_R3G3B2_UNORM:
- return format == GL_RGB && type == GL_UNSIGNED_BYTE_2_3_3_REV;
-
- case MESA_FORMAT_A4B4G4R4_UNORM:
- if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_R4G4B4A4_UNORM:
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes)
- return GL_TRUE;
-
- if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_R5G5B5A1_UNORM:
- return format == GL_RGBA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV;
-
- case MESA_FORMAT_A2B10G10R10_UNORM:
- return format == GL_RGBA && type == GL_UNSIGNED_INT_10_10_10_2;
-
- case MESA_FORMAT_A2B10G10R10_UINT:
- return format == GL_RGBA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2;
-
- case MESA_FORMAT_A2R10G10B10_UNORM:
- return format == GL_BGRA && type == GL_UNSIGNED_INT_10_10_10_2;
-
- case MESA_FORMAT_A2R10G10B10_UINT:
- return format == GL_BGRA_INTEGER_EXT && type == GL_UNSIGNED_INT_10_10_10_2;
-
- case MESA_FORMAT_A_UNORM8:
- return format == GL_ALPHA && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_A_UNORM16:
- return format == GL_ALPHA && type == GL_UNSIGNED_SHORT && !swapBytes;
- case MESA_FORMAT_L_UNORM8:
- case MESA_FORMAT_L_SRGB8:
- return format == GL_LUMINANCE && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_L_UNORM16:
- return format == GL_LUMINANCE && type == GL_UNSIGNED_SHORT && !swapBytes;
- case MESA_FORMAT_I_UNORM8:
- return format == GL_RED && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_I_UNORM16:
- return format == GL_RED && type == GL_UNSIGNED_SHORT && !swapBytes;
-
- case MESA_FORMAT_YCBCR:
- return format == GL_YCBCR_MESA &&
- ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian != swapBytes) ||
- (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian == swapBytes));
- case MESA_FORMAT_YCBCR_REV:
- return format == GL_YCBCR_MESA &&
- ((type == GL_UNSIGNED_SHORT_8_8_MESA && littleEndian == swapBytes) ||
- (type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes));
-
- case MESA_FORMAT_R_UNORM8:
- return format == GL_RED && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_R8G8_UNORM:
- return format == GL_RG && type == GL_UNSIGNED_BYTE && littleEndian;
- case MESA_FORMAT_G8R8_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_R_UNORM16:
- return format == GL_RED && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_R16G16_UNORM:
- return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian &&
- !swapBytes;
- case MESA_FORMAT_G16R16_UNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_B10G10R10A2_UNORM:
- return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
- !swapBytes;
-
- case MESA_FORMAT_S8_UINT_Z24_UNORM:
- return format == GL_DEPTH_STENCIL && type == GL_UNSIGNED_INT_24_8 &&
- !swapBytes;
- case MESA_FORMAT_X8_UINT_Z24_UNORM:
- case MESA_FORMAT_Z24_UNORM_S8_UINT:
- return GL_FALSE;
-
- case MESA_FORMAT_Z_UNORM16:
- return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
-
- case MESA_FORMAT_Z24_UNORM_X8_UINT:
- return GL_FALSE;
-
- case MESA_FORMAT_Z_UNORM32:
- return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT &&
- !swapBytes;
-
- case MESA_FORMAT_S_UINT8:
- return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE;
-
- case MESA_FORMAT_RGBA_FLOAT32:
- return format == GL_RGBA && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_RGBA_FLOAT16:
- return format == GL_RGBA && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_RGB_FLOAT32:
- return format == GL_RGB && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_RGB_FLOAT16:
- return format == GL_RGB && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_A_FLOAT32:
- return format == GL_ALPHA && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_A_FLOAT16:
- return format == GL_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_L_FLOAT32:
- return format == GL_LUMINANCE && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_L_FLOAT16:
- return format == GL_LUMINANCE && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_LA_FLOAT32:
- return format == GL_LUMINANCE_ALPHA && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_LA_FLOAT16:
- return format == GL_LUMINANCE_ALPHA && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_I_FLOAT32:
- return format == GL_RED && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_I_FLOAT16:
- return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_R_FLOAT32:
- return format == GL_RED && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_R_FLOAT16:
- return format == GL_RED && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_RG_FLOAT32:
- return format == GL_RG && type == GL_FLOAT && !swapBytes;
- case MESA_FORMAT_RG_FLOAT16:
- return format == GL_RG && type == GL_HALF_FLOAT && !swapBytes;
-
- case MESA_FORMAT_A_UINT8:
- return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_A_UINT16:
- return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_A_UINT32:
- return format == GL_ALPHA_INTEGER && type == GL_UNSIGNED_INT &&
- !swapBytes;
- case MESA_FORMAT_A_SINT8:
- return format == GL_ALPHA_INTEGER && type == GL_BYTE;
- case MESA_FORMAT_A_SINT16:
- return format == GL_ALPHA_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_A_SINT32:
- return format == GL_ALPHA_INTEGER && type == GL_INT && !swapBytes;
-
- case MESA_FORMAT_I_UINT8:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_I_UINT16:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
- case MESA_FORMAT_I_UINT32:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
- case MESA_FORMAT_I_SINT8:
- return format == GL_RED_INTEGER && type == GL_BYTE;
- case MESA_FORMAT_I_SINT16:
- return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_I_SINT32:
- return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
-
- case MESA_FORMAT_L_UINT8:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_L_UINT16:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_L_UINT32:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_UNSIGNED_INT &&
- !swapBytes;
- case MESA_FORMAT_L_SINT8:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_BYTE;
- case MESA_FORMAT_L_SINT16:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_SHORT &&
- !swapBytes;
- case MESA_FORMAT_L_SINT32:
- return format == GL_LUMINANCE_INTEGER_EXT && type == GL_INT && !swapBytes;
-
- case MESA_FORMAT_LA_UINT8:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
- type == GL_UNSIGNED_BYTE && !swapBytes;
- case MESA_FORMAT_LA_UINT16:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
- type == GL_UNSIGNED_SHORT && !swapBytes;
- case MESA_FORMAT_LA_UINT32:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT &&
- type == GL_UNSIGNED_INT && !swapBytes;
- case MESA_FORMAT_LA_SINT8:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_BYTE &&
- !swapBytes;
- case MESA_FORMAT_LA_SINT16:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_SHORT &&
- !swapBytes;
- case MESA_FORMAT_LA_SINT32:
- return format == GL_LUMINANCE_ALPHA_INTEGER_EXT && type == GL_INT &&
- !swapBytes;
-
- case MESA_FORMAT_R_SINT8:
- return format == GL_RED_INTEGER && type == GL_BYTE;
- case MESA_FORMAT_RG_SINT8:
- return format == GL_RG_INTEGER && type == GL_BYTE && !swapBytes;
- case MESA_FORMAT_RGB_SINT8:
- return format == GL_RGB_INTEGER && type == GL_BYTE && !swapBytes;
- case MESA_FORMAT_RGBA_SINT8:
- return format == GL_RGBA_INTEGER && type == GL_BYTE && !swapBytes;
- case MESA_FORMAT_R_SINT16:
- return format == GL_RED_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_RG_SINT16:
- return format == GL_RG_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_RGB_SINT16:
- return format == GL_RGB_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_RGBA_SINT16:
- return format == GL_RGBA_INTEGER && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_R_SINT32:
- return format == GL_RED_INTEGER && type == GL_INT && !swapBytes;
- case MESA_FORMAT_RG_SINT32:
- return format == GL_RG_INTEGER && type == GL_INT && !swapBytes;
- case MESA_FORMAT_RGB_SINT32:
- return format == GL_RGB_INTEGER && type == GL_INT && !swapBytes;
- case MESA_FORMAT_RGBA_SINT32:
- return format == GL_RGBA_INTEGER && type == GL_INT && !swapBytes;
-
- case MESA_FORMAT_R_UINT8:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_RG_UINT8:
- return format == GL_RG_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
- case MESA_FORMAT_RGB_UINT8:
- return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE && !swapBytes;
- case MESA_FORMAT_RGBA_UINT8:
- return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_BYTE &&
- !swapBytes;
- case MESA_FORMAT_R_UINT16:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_RG_UINT16:
- return format == GL_RG_INTEGER && type == GL_UNSIGNED_SHORT && !swapBytes;
- case MESA_FORMAT_RGB_UINT16:
- return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_RGBA_UINT16:
- return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
- case MESA_FORMAT_R_UINT32:
- return format == GL_RED_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
- case MESA_FORMAT_RG_UINT32:
- return format == GL_RG_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
- case MESA_FORMAT_RGB_UINT32:
- return format == GL_RGB_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
- case MESA_FORMAT_RGBA_UINT32:
- return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT && !swapBytes;
-
- case MESA_FORMAT_R_SNORM8:
- return format == GL_RED && type == GL_BYTE;
- case MESA_FORMAT_R8G8_SNORM:
- return format == GL_RG && type == GL_BYTE && littleEndian &&
- !swapBytes;
- case MESA_FORMAT_X8B8G8R8_SNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_A8B8G8R8_SNORM:
- if (format == GL_RGBA && type == GL_BYTE && !littleEndian)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_R8G8B8A8_SNORM:
- if (format == GL_RGBA && type == GL_BYTE && littleEndian)
- return GL_TRUE;
-
- if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian)
- return GL_TRUE;
-
- return GL_FALSE;
-
- case MESA_FORMAT_R_SNORM16:
- return format == GL_RED && type == GL_SHORT &&
- !swapBytes;
- case MESA_FORMAT_R16G16_SNORM:
- return format == GL_RG && type == GL_SHORT && littleEndian && !swapBytes;
- case MESA_FORMAT_RGB_SNORM16:
- return format == GL_RGB && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_RGBA_SNORM16:
- return format == GL_RGBA && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_RGBA_UNORM16:
- return format == GL_RGBA && type == GL_UNSIGNED_SHORT &&
- !swapBytes;
-
- case MESA_FORMAT_A_SNORM8:
- return format == GL_ALPHA && type == GL_BYTE;
- case MESA_FORMAT_L_SNORM8:
- return format == GL_LUMINANCE && type == GL_BYTE;
- case MESA_FORMAT_L8A8_SNORM:
- return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
- littleEndian && !swapBytes;
- case MESA_FORMAT_A8L8_SNORM:
- return format == GL_LUMINANCE_ALPHA && type == GL_BYTE &&
- !littleEndian && !swapBytes;
- case MESA_FORMAT_I_SNORM8:
- return format == GL_RED && type == GL_BYTE;
- case MESA_FORMAT_A_SNORM16:
- return format == GL_ALPHA && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_L_SNORM16:
- return format == GL_LUMINANCE && type == GL_SHORT && !swapBytes;
- case MESA_FORMAT_LA_SNORM16:
- return format == GL_LUMINANCE_ALPHA && type == GL_SHORT &&
- littleEndian && !swapBytes;
- case MESA_FORMAT_I_SNORM16:
- return format == GL_RED && type == GL_SHORT && littleEndian &&
- !swapBytes;
-
- case MESA_FORMAT_B10G10R10A2_UINT:
- return (format == GL_BGRA_INTEGER_EXT &&
- type == GL_UNSIGNED_INT_2_10_10_10_REV &&
- !swapBytes);
-
- case MESA_FORMAT_R10G10B10A2_UINT:
- return (format == GL_RGBA_INTEGER_EXT &&
- type == GL_UNSIGNED_INT_2_10_10_10_REV &&
- !swapBytes);
-
- case MESA_FORMAT_R9G9B9E5_FLOAT:
- return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV &&
- !swapBytes;
-
- case MESA_FORMAT_R11G11B10_FLOAT:
- return format == GL_RGB && type == GL_UNSIGNED_INT_10F_11F_11F_REV &&
- !swapBytes;
+ if (_mesa_is_format_compressed(mformat)) {
+ if (error)
+ *error = GL_INVALID_ENUM;
+ return false;
+ }
- case MESA_FORMAT_Z_FLOAT32:
- return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes;
+ if (swapBytes && !_mesa_swap_bytes_in_type_enum(&type))
+ return false;
- case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
- return format == GL_DEPTH_STENCIL &&
- type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes;
+ /* format/type don't include srgb and should match regardless of it. */
+ mformat = _mesa_get_srgb_format_linear(mformat);
- case MESA_FORMAT_B4G4R4X4_UNORM:
- case MESA_FORMAT_B5G5R5X1_UNORM:
- case MESA_FORMAT_R8G8B8X8_SNORM:
- case MESA_FORMAT_R8G8B8X8_SRGB:
- case MESA_FORMAT_X8B8G8R8_SRGB:
- case MESA_FORMAT_RGBX_UINT8:
- case MESA_FORMAT_RGBX_SINT8:
- case MESA_FORMAT_B10G10R10X2_UNORM:
- case MESA_FORMAT_R10G10B10X2_UNORM:
- case MESA_FORMAT_RGBX_UNORM16:
- case MESA_FORMAT_RGBX_SNORM16:
- case MESA_FORMAT_RGBX_FLOAT16:
- case MESA_FORMAT_RGBX_UINT16:
- case MESA_FORMAT_RGBX_SINT16:
- case MESA_FORMAT_RGBX_FLOAT32:
- case MESA_FORMAT_RGBX_UINT32:
- case MESA_FORMAT_RGBX_SINT32:
- return GL_FALSE;
-
- case MESA_FORMAT_R10G10B10A2_UNORM:
- return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
- !swapBytes;
+ /* intensity formats are uploaded with GL_RED, and we want to find
+ * memcpy matches for them.
+ */
+ mformat = _mesa_get_intensity_format_red(mformat);
- case MESA_FORMAT_G8R8_SNORM:
- return format == GL_RG && type == GL_BYTE && !littleEndian &&
- !swapBytes;
+ if (format == GL_COLOR_INDEX)
+ return false;
- case MESA_FORMAT_G16R16_SNORM:
- return format == GL_RG && type == GL_SHORT && !littleEndian &&
- !swapBytes;
+ mesa_format other_format = _mesa_format_from_format_and_type(format, type);
+ if (_mesa_format_is_mesa_array_format(other_format))
+ other_format = _mesa_format_from_array_format(other_format);
- case MESA_FORMAT_B8G8R8X8_SRGB:
- case MESA_FORMAT_X8R8G8B8_SRGB:
- return GL_FALSE;
- default:
- assert(_mesa_is_format_compressed(mesa_format));
- if (error)
- *error = GL_INVALID_ENUM;
- }
- return GL_FALSE;
+ return other_format == mformat;
}
projects / mesa.git / blobdiff