*/
+#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_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;
}
_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);
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
if (info->ArrayFormat && !_mesa_little_endian() &&
info->Layout == MESA_FORMAT_LAYOUT_PACKED)
return _mesa_array_format_flip_channels(info->ArrayFormat);
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;
}
/** 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:
GLenum
_mesa_get_format_color_encoding(mesa_format format)
{
- /* XXX this info should be encoded in gl_format_info */
- switch (format) {
- case MESA_FORMAT_BGR_SRGB8:
- case MESA_FORMAT_A8B8G8R8_SRGB:
- case MESA_FORMAT_B8G8R8A8_SRGB:
- case MESA_FORMAT_A8R8G8B8_SRGB:
- case MESA_FORMAT_R8G8B8A8_SRGB:
- case MESA_FORMAT_L_SRGB8:
- case MESA_FORMAT_L8A8_SRGB:
- case MESA_FORMAT_A8L8_SRGB:
- case MESA_FORMAT_SRGB_DXT1:
- case MESA_FORMAT_SRGBA_DXT1:
- case MESA_FORMAT_SRGBA_DXT3:
- case MESA_FORMAT_SRGBA_DXT5:
- case MESA_FORMAT_R8G8B8X8_SRGB:
- case MESA_FORMAT_ETC2_SRGB8:
- case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
- case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
- case MESA_FORMAT_B8G8R8X8_SRGB:
- case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
- return GL_SRGB;
- default:
- return GL_LINEAR;
- }
+ const struct mesa_format_info *info = _mesa_get_format_info(format);
+ return info->IsSRGBFormat ? GL_SRGB : GL_LINEAR;
}
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_B8G8R8X8_SRGB:
- format = MESA_FORMAT_B8G8R8X8_UNORM;
- break;
- case MESA_FORMAT_X8R8G8B8_SRGB:
- format = MESA_FORMAT_X8R8G8B8_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:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10:
+ case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12:
+ return true;
default:
- break;
+ return false;
}
- return format;
}
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:
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;
}
}
-/**
- * Debug/test: check that all uncompressed formats are handled in the
- * _mesa_uncompressed_format_to_type_and_comps() function. When new pixel
- * formats are added to Mesa, that function needs to be updated.
- * This is a no-op after the first call.
- */
-static void
-check_format_to_type_and_comps(void)
-{
- mesa_format f;
-
- for (f = MESA_FORMAT_NONE + 1; f < MESA_FORMAT_COUNT; f++) {
- GLenum datatype = 0;
- GLuint comps = 0;
- /* This function will emit a problem/warning if the format is
- * not handled.
- */
- if (!_mesa_is_format_compressed(f))
- _mesa_uncompressed_format_to_type_and_comps(f, &datatype, &comps);
- }
-}
-
-/**
- * Do sanity checking of the format info table.
- */
-void
-_mesa_test_formats(void)
-{
- GLuint i;
-
- STATIC_ASSERT(ARRAY_SIZE(format_info) == MESA_FORMAT_COUNT);
-
- for (i = 0; i < MESA_FORMAT_COUNT; i++) {
- const struct gl_format_info *info = _mesa_get_format_info(i);
- assert(info);
-
- assert(info->Name == i);
-
- if (info->Name == MESA_FORMAT_NONE)
- continue;
-
- if (info->BlockWidth == 1 && info->BlockHeight == 1) {
- if (info->RedBits > 0) {
- GLuint t = info->RedBits + info->GreenBits
- + info->BlueBits + info->AlphaBits;
- assert(t / 8 <= info->BytesPerBlock);
- (void) t;
- }
- }
-
- assert(info->DataType == GL_UNSIGNED_NORMALIZED ||
- info->DataType == GL_SIGNED_NORMALIZED ||
- info->DataType == GL_UNSIGNED_INT ||
- info->DataType == GL_INT ||
- info->DataType == GL_FLOAT ||
- /* Z32_FLOAT_X24S8 has DataType of GL_NONE */
- info->DataType == GL_NONE);
-
- if (info->BaseFormat == GL_RGB) {
- assert(info->RedBits > 0);
- assert(info->GreenBits > 0);
- assert(info->BlueBits > 0);
- assert(info->AlphaBits == 0);
- assert(info->LuminanceBits == 0);
- assert(info->IntensityBits == 0);
- }
- else if (info->BaseFormat == GL_RGBA) {
- assert(info->RedBits > 0);
- assert(info->GreenBits > 0);
- assert(info->BlueBits > 0);
- assert(info->AlphaBits > 0);
- assert(info->LuminanceBits == 0);
- assert(info->IntensityBits == 0);
- }
- else if (info->BaseFormat == GL_RG) {
- assert(info->RedBits > 0);
- assert(info->GreenBits > 0);
- assert(info->BlueBits == 0);
- assert(info->AlphaBits == 0);
- assert(info->LuminanceBits == 0);
- assert(info->IntensityBits == 0);
- }
- else if (info->BaseFormat == GL_RED) {
- assert(info->RedBits > 0);
- assert(info->GreenBits == 0);
- assert(info->BlueBits == 0);
- assert(info->AlphaBits == 0);
- assert(info->LuminanceBits == 0);
- assert(info->IntensityBits == 0);
- }
- else if (info->BaseFormat == GL_LUMINANCE) {
- assert(info->RedBits == 0);
- assert(info->GreenBits == 0);
- assert(info->BlueBits == 0);
- assert(info->AlphaBits == 0);
- assert(info->LuminanceBits > 0);
- assert(info->IntensityBits == 0);
- }
- else if (info->BaseFormat == GL_INTENSITY) {
- assert(info->RedBits == 0);
- assert(info->GreenBits == 0);
- assert(info->BlueBits == 0);
- assert(info->AlphaBits == 0);
- assert(info->LuminanceBits == 0);
- assert(info->IntensityBits > 0);
- }
- }
-
- check_format_to_type_and_comps();
-}
-
-
/**
* Return datatype and number of components per texel for the given
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;
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;
*comps = 4;
return;
case MESA_FORMAT_L_SRGB8:
+ case MESA_FORMAT_R_SRGB8:
*datatype = GL_UNSIGNED_BYTE;
*comps = 1;
return;
case MESA_FORMAT_COUNT:
assert(0);
return;
-
- case MESA_FORMAT_RGB_FXT1:
- case MESA_FORMAT_RGBA_FXT1:
- case MESA_FORMAT_RGB_DXT1:
- case MESA_FORMAT_RGBA_DXT1:
- case MESA_FORMAT_RGBA_DXT3:
- case MESA_FORMAT_RGBA_DXT5:
- case MESA_FORMAT_SRGB_DXT1:
- case MESA_FORMAT_SRGBA_DXT1:
- case MESA_FORMAT_SRGBA_DXT3:
- case MESA_FORMAT_SRGBA_DXT5:
- case MESA_FORMAT_R_RGTC1_UNORM:
- case MESA_FORMAT_R_RGTC1_SNORM:
- case MESA_FORMAT_RG_RGTC2_UNORM:
- case MESA_FORMAT_RG_RGTC2_SNORM:
- case MESA_FORMAT_L_LATC1_UNORM:
- case MESA_FORMAT_L_LATC1_SNORM:
- case MESA_FORMAT_LA_LATC2_UNORM:
- case MESA_FORMAT_LA_LATC2_SNORM:
- case MESA_FORMAT_ETC1_RGB8:
- case MESA_FORMAT_ETC2_RGB8:
- case MESA_FORMAT_ETC2_SRGB8:
- case MESA_FORMAT_ETC2_RGBA8_EAC:
- case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
- case MESA_FORMAT_ETC2_R11_EAC:
- case MESA_FORMAT_ETC2_RG11_EAC:
- case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
- case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
- case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
- case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
- case MESA_FORMAT_BPTC_RGBA_UNORM:
- case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
- case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
- case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
- assert(_mesa_is_format_compressed(format));
- case MESA_FORMAT_NONE:
- /* For debug builds, warn if any formats are not handled */
-#ifdef DEBUG
default:
-#endif
+ /* Warn if any formats are not handled */
_mesa_problem(NULL, "bad format %s in _mesa_uncompressed_format_to_type_and_comps",
_mesa_get_format_name(format));
+ assert(format == MESA_FORMAT_NONE ||
+ _mesa_is_format_compressed(format));
*datatype = 0;
*comps = 1;
}
* \param format the user-specified image format
* \param type the user-specified image datatype
* \param swapBytes typically the current pixel pack/unpack byteswap state
- * \return GL_TRUE if the formats match, GL_FALSE otherwise.
+ * \param[out] error GL_NO_ERROR if format is an expected input.
+ * GL_INVALID_ENUM if format is an unexpected input.
+ * \return true if the formats match, false otherwise.
*/
-GLboolean
+bool
_mesa_format_matches_format_and_type(mesa_format mesa_format,
GLenum format, GLenum type,
- GLboolean swapBytes)
+ bool swapBytes, GLenum *error)
{
- const GLboolean littleEndian = _mesa_little_endian();
+ const bool 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 false.
+ *
* For sanity, please keep this switch statement ordered the same as the
* enums in formats.h.
*/
case MESA_FORMAT_NONE:
case MESA_FORMAT_COUNT:
- return GL_FALSE;
+ return 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;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV
&& !swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8
&& swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return 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;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8 &&
!swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return 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;
+ return true;
if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return 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;
+ return true;
if (format == GL_BGRA && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_BGRA && type == GL_UNSIGNED_BYTE && !littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return false;
case MESA_FORMAT_X8B8G8R8_UNORM:
case MESA_FORMAT_R8G8B8X8_UNORM:
- return GL_FALSE;
+ return false;
case MESA_FORMAT_B8G8R8X8_UNORM:
case MESA_FORMAT_X8R8G8B8_UNORM:
- return GL_FALSE;
+ return false;
case MESA_FORMAT_BGR_UNORM8:
case MESA_FORMAT_BGR_SRGB8:
!swapBytes;
case MESA_FORMAT_A4R4G4B4_UNORM:
- return GL_FALSE;
+ return false;
case MESA_FORMAT_A1B5G5R5_UNORM:
return format == GL_RGBA && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
!swapBytes;
+ case MESA_FORMAT_X1B5G5R5_UNORM:
+ return format == GL_RGB && 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;
!swapBytes;
case MESA_FORMAT_L4A4_UNORM:
- return GL_FALSE;
+ return 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;
+ return 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;
+ return false;
case MESA_FORMAT_B2G3R3_UNORM:
return format == GL_RGB && type == GL_UNSIGNED_BYTE_3_3_2;
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;
+ return 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 true;
- return GL_FALSE;
+ return false;
case MESA_FORMAT_R4G4B4A4_UNORM:
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes)
- return GL_TRUE;
+ return true;
if (format == GL_RGBA && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return false;
case MESA_FORMAT_R5G5B5A1_UNORM:
return format == GL_RGBA && type == GL_UNSIGNED_SHORT_1_5_5_5_REV;
(type == GL_UNSIGNED_SHORT_8_8_REV_MESA && littleEndian != swapBytes));
case MESA_FORMAT_R_UNORM8:
+ case MESA_FORMAT_R_SRGB8:
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;
+ return false;
case MESA_FORMAT_R_UNORM16:
return format == GL_RED && type == GL_UNSIGNED_SHORT &&
return format == GL_RG && type == GL_UNSIGNED_SHORT && littleEndian &&
!swapBytes;
case MESA_FORMAT_G16R16_UNORM:
- return GL_FALSE;
+ return false;
case MESA_FORMAT_B10G10R10A2_UNORM:
return format == GL_BGRA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
!swapBytes;
case MESA_FORMAT_X8_UINT_Z24_UNORM:
case MESA_FORMAT_Z24_UNORM_S8_UINT:
- return GL_FALSE;
+ return 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;
+ return false;
case MESA_FORMAT_Z_UNORM32:
return format == GL_DEPTH_COMPONENT && type == GL_UNSIGNED_INT &&
case MESA_FORMAT_S_UINT8:
return format == GL_STENCIL_INDEX && type == GL_UNSIGNED_BYTE;
- case MESA_FORMAT_SRGB_DXT1:
- case MESA_FORMAT_SRGBA_DXT1:
- case MESA_FORMAT_SRGBA_DXT3:
- case MESA_FORMAT_SRGBA_DXT5:
- return GL_FALSE;
-
- case MESA_FORMAT_RGB_FXT1:
- case MESA_FORMAT_RGBA_FXT1:
- case MESA_FORMAT_RGB_DXT1:
- case MESA_FORMAT_RGBA_DXT1:
- case MESA_FORMAT_RGBA_DXT3:
- case MESA_FORMAT_RGBA_DXT5:
- return GL_FALSE;
-
- case MESA_FORMAT_BPTC_RGBA_UNORM:
- case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
- case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
- case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
- return GL_FALSE;
-
case MESA_FORMAT_RGBA_FLOAT32:
return format == GL_RGBA && type == GL_FLOAT && !swapBytes;
case MESA_FORMAT_RGBA_FLOAT16:
return format == GL_RG && type == GL_BYTE && littleEndian &&
!swapBytes;
case MESA_FORMAT_X8B8G8R8_SNORM:
- return GL_FALSE;
+ return false;
case MESA_FORMAT_A8B8G8R8_SNORM:
if (format == GL_RGBA && type == GL_BYTE && !littleEndian)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_BYTE && littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return false;
case MESA_FORMAT_R8G8B8A8_SNORM:
if (format == GL_RGBA && type == GL_BYTE && littleEndian)
- return GL_TRUE;
+ return true;
if (format == GL_ABGR_EXT && type == GL_BYTE && !littleEndian)
- return GL_TRUE;
+ return true;
- return GL_FALSE;
+ return false;
case MESA_FORMAT_R_SNORM16:
return format == GL_RED && type == GL_SHORT &&
return format == GL_RGBA && type == GL_UNSIGNED_SHORT &&
!swapBytes;
- case MESA_FORMAT_R_RGTC1_UNORM:
- case MESA_FORMAT_R_RGTC1_SNORM:
- case MESA_FORMAT_RG_RGTC2_UNORM:
- case MESA_FORMAT_RG_RGTC2_SNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_L_LATC1_UNORM:
- case MESA_FORMAT_L_LATC1_SNORM:
- case MESA_FORMAT_LA_LATC2_UNORM:
- case MESA_FORMAT_LA_LATC2_SNORM:
- return GL_FALSE;
-
- case MESA_FORMAT_ETC1_RGB8:
- case MESA_FORMAT_ETC2_RGB8:
- case MESA_FORMAT_ETC2_SRGB8:
- case MESA_FORMAT_ETC2_RGBA8_EAC:
- case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
- case MESA_FORMAT_ETC2_R11_EAC:
- case MESA_FORMAT_ETC2_RG11_EAC:
- case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
- case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
- case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
- case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
- return GL_FALSE;
-
case MESA_FORMAT_A_SNORM8:
return format == GL_ALPHA && type == GL_BYTE;
case MESA_FORMAT_L_SNORM8:
type == GL_UNSIGNED_INT_2_10_10_10_REV &&
!swapBytes);
+ case MESA_FORMAT_B5G6R5_UINT:
+ return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5;
+
+ case MESA_FORMAT_R5G6B5_UINT:
+ return format == GL_RGB_INTEGER && type == GL_UNSIGNED_SHORT_5_6_5_REV;
+
+ case MESA_FORMAT_B2G3R3_UINT:
+ return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_3_3_2;
+
+ case MESA_FORMAT_R3G3B2_UINT:
+ return format == GL_RGB_INTEGER && type == GL_UNSIGNED_BYTE_2_3_3_REV;
+
+ case MESA_FORMAT_A4B4G4R4_UINT:
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && !swapBytes)
+ return true;
+
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && swapBytes)
+ return true;
+ return false;
+
+ case MESA_FORMAT_R4G4B4A4_UINT:
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV && !swapBytes)
+ return true;
+
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4 && swapBytes)
+ return true;
+
+ return false;
+
+ case MESA_FORMAT_B4G4R4A4_UINT:
+ return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_4_4_4_4_REV &&
+ !swapBytes;
+
+ case MESA_FORMAT_A4R4G4B4_UINT:
+ return false;
+
+ case MESA_FORMAT_A1B5G5R5_UINT:
+ return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
+ !swapBytes;
+
+ case MESA_FORMAT_B5G5R5A1_UINT:
+ return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV &&
+ !swapBytes;
+
+ case MESA_FORMAT_A1R5G5B5_UINT:
+ return format == GL_BGRA_INTEGER && type == GL_UNSIGNED_SHORT_5_5_5_1 &&
+ !swapBytes;
+
+ case MESA_FORMAT_R5G5B5A1_UINT:
+ return format == GL_RGBA_INTEGER && type == GL_UNSIGNED_SHORT_1_5_5_5_REV;
+
+ case MESA_FORMAT_A8B8G8R8_UINT:
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && !swapBytes)
+ return true;
+
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV && swapBytes)
+ return true;
+ return false;
+
+ case MESA_FORMAT_A8R8G8B8_UINT:
+ if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 &&
+ !swapBytes)
+ return true;
+
+ if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
+ swapBytes)
+ return true;
+
+ return false;
+
+ case MESA_FORMAT_R8G8B8A8_UINT:
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
+ !swapBytes)
+ return true;
+
+ if (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
+ return true;
+
+ return false;
+
+ case MESA_FORMAT_B8G8R8A8_UINT:
+ if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8_REV &&
+ !swapBytes)
+ return true;
+
+ if (format == GL_BGRA_INTEGER && type == GL_UNSIGNED_INT_8_8_8_8 && swapBytes)
+ return true;
+
+ return false;
+
case MESA_FORMAT_R9G9B9E5_FLOAT:
return format == GL_RGB && type == GL_UNSIGNED_INT_5_9_9_9_REV &&
!swapBytes;
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_FLOAT32:
case MESA_FORMAT_RGBX_UINT32:
case MESA_FORMAT_RGBX_SINT32:
- return GL_FALSE;
+ return false;
+ case MESA_FORMAT_R10G10B10X2_UNORM:
+ return format == GL_RGB && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
+ !swapBytes;
case MESA_FORMAT_R10G10B10A2_UNORM:
return format == GL_RGBA && type == GL_UNSIGNED_INT_2_10_10_10_REV &&
!swapBytes;
case MESA_FORMAT_B8G8R8X8_SRGB:
case MESA_FORMAT_X8R8G8B8_SRGB:
- return GL_FALSE;
+ return false;
+ default:
+ assert(_mesa_is_format_compressed(mesa_format));
+ if (error)
+ *error = GL_INVALID_ENUM;
}
-
- return GL_FALSE;
+ return false;
}
projects / mesa.git / blobdiff