X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fformats.c;h=77221117dcea15d15338880707aeae190905234f;hb=ee4f1bc187536d32c30f4505247750754e27f6e4;hp=8dd07d88f403492393205aa354ed6411767381c8;hpb=9b387b5d3f4103c51079ea5298d33086af6da433;p=mesa.git diff --git a/src/mesa/main/formats.c b/src/mesa/main/formats.c index 8dd07d88f40..77221117dce 100644 --- a/src/mesa/main/formats.c +++ b/src/mesa/main/formats.c @@ -24,6 +24,7 @@ */ +#include "errors.h" #include "imports.h" #include "formats.h" #include "macros.h" @@ -34,7 +35,7 @@ /** * Information about texture formats. */ -struct gl_format_info +struct mesa_format_info { mesa_format Name; @@ -56,22 +57,22 @@ struct gl_format_info */ 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; @@ -79,10 +80,10 @@ struct gl_format_info #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; @@ -93,7 +94,7 @@ _mesa_get_format_info(mesa_format format) 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; } @@ -104,12 +105,17 @@ _mesa_get_format_name(mesa_format format) * 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)); @@ -125,28 +131,32 @@ _mesa_get_format_bytes(mesa_format 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; @@ -158,11 +168,13 @@ _mesa_get_format_bits(mesa_format format, GLenum pname) 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()"); @@ -171,11 +183,11 @@ _mesa_get_format_bits(mesa_format format, GLenum pname) } -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); @@ -188,21 +200,11 @@ _mesa_get_format_max_bits(mesa_format format) /** * 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; } @@ -220,7 +222,7 @@ _mesa_get_format_layout(mesa_format format) 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; } @@ -230,6 +232,15 @@ get_base_format_for_array_format(mesa_array_format format) 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); @@ -300,7 +311,7 @@ GLenum _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); @@ -316,14 +327,39 @@ _mesa_get_format_base_format(uint32_t 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 gl_format_info *info = _mesa_get_format_info(format); + 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 mesa_format_info *info = _mesa_get_format_info(format); + *bw = info->BlockWidth; + *bh = info->BlockHeight; + *bd = info->BlockDepth; +} + + /** * Returns the an array of four numbers representing the transformation * from the RGBA or SZ colorspace to the given format. For array formats, @@ -346,7 +382,7 @@ _mesa_get_format_block_size(mesa_format format, GLuint *bw, GLuint *bh) 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)); } @@ -388,17 +424,24 @@ _mesa_array_format_flip_channels(mesa_array_format format) 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) { @@ -408,7 +451,7 @@ 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; @@ -425,11 +468,11 @@ format_array_format_table_init(void) 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. @@ -444,6 +487,8 @@ format_array_format_table_init(void) (void *)(intptr_t)array_format, (void *)(intptr_t)f); } + + atexit(format_array_format_table_destroy); } mesa_format @@ -471,10 +516,10 @@ _mesa_format_from_array_format(uint32_t array_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; } @@ -482,10 +527,10 @@ _mesa_is_format_compressed(mesa_format format) /** * 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; } @@ -494,10 +539,10 @@ _mesa_is_format_packed_depth_stencil(mesa_format format) /** * 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 && @@ -508,10 +553,10 @@ _mesa_is_format_integer_color(mesa_format format) /** * 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); } @@ -519,16 +564,16 @@ _mesa_is_format_unsigned(mesa_format format) /** * 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); @@ -538,10 +583,10 @@ _mesa_is_format_signed(mesa_format format) /** * 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); } @@ -549,10 +594,10 @@ _mesa_is_format_integer(mesa_format format) /** * 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: @@ -563,19 +608,13 @@ _mesa_is_format_color_format(mesa_format format) } } - -/** - * 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. @@ -594,85 +633,52 @@ _mesa_is_format_etc2(mesa_format format) 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; } @@ -705,32 +711,35 @@ _mesa_get_uncompressed_format(mesa_format 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; @@ -738,18 +747,16 @@ _mesa_get_uncompressed_format(mesa_format format) 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) + @@ -768,7 +775,7 @@ _mesa_format_num_components(mesa_format format) 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 && @@ -794,25 +801,27 @@ _mesa_format_has_color_component(mesa_format format, int component) * 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; } @@ -821,45 +830,45 @@ _mesa_format_image_size(mesa_format format, GLsizei width, * 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; } } @@ -883,6 +892,10 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -893,6 +906,8 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -900,6 +915,8 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -907,6 +924,8 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -917,6 +936,8 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -926,18 +947,14 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, *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; @@ -951,19 +968,23 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, 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; @@ -979,6 +1000,7 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, return; case MESA_FORMAT_B2G3R3_UNORM: + case MESA_FORMAT_B2G3R3_UINT: *datatype = GL_UNSIGNED_BYTE_3_3_2; *comps = 3; return; @@ -1045,9 +1067,8 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, *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; @@ -1070,7 +1091,7 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, *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; @@ -1096,11 +1117,11 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, *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; @@ -1383,16 +1404,6 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, *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; @@ -1422,567 +1433,40 @@ _mesa_uncompressed_format_to_type_and_comps(mesa_format format, * \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; - - case MESA_FORMAT_Z_FLOAT32: - return format == GL_DEPTH_COMPONENT && type == GL_FLOAT && !swapBytes; + if (_mesa_is_format_compressed(mformat)) { + if (error) + *error = GL_INVALID_ENUM; + return false; + } - case MESA_FORMAT_Z32_FLOAT_S8X24_UINT: - return format == GL_DEPTH_STENCIL && - type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV && !swapBytes; + if (swapBytes && !_mesa_swap_bytes_in_type_enum(&type)) + return false; - 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; + /* format/type don't include srgb and should match regardless of it. */ + mformat = _mesa_get_srgb_format_linear(mformat); - 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(format)); - if (error) - *error = GL_INVALID_ENUM; - } - return GL_FALSE; + return other_format == mformat; }