X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Ftexcompress.c;h=1c128e42c2a98929ffdd93a3997758bbc09431db;hb=9d670fd86cc13df0ddff5c6fcb0835926e9a8088;hp=b3fdfd7677944d33fb07283515191eb89dfa1ade;hpb=75211f4367cab6477890111211d3437bf469670b;p=mesa.git diff --git a/src/mesa/main/texcompress.c b/src/mesa/main/texcompress.c index b3fdfd76779..1c128e42c2a 100644 --- a/src/mesa/main/texcompress.c +++ b/src/mesa/main/texcompress.c @@ -1,6 +1,5 @@ /* * Mesa 3-D graphics library - * Version: 6.5.1 * * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. * Copyright (c) 2008 VMware, Inc. @@ -18,9 +17,10 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN - * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. */ @@ -32,17 +32,16 @@ #include "glheader.h" #include "imports.h" -#include "colormac.h" #include "context.h" #include "formats.h" -#include "mfeatures.h" #include "mtypes.h" +#include "context.h" #include "texcompress.h" #include "texcompress_fxt1.h" #include "texcompress_rgtc.h" #include "texcompress_s3tc.h" #include "texcompress_etc.h" -#include "swrast/s_context.h" +#include "texcompress_bptc.h" /** @@ -93,20 +92,26 @@ _mesa_gl_compressed_format_base_format(GLenum format) case GL_COMPRESSED_RGB: case GL_COMPRESSED_SRGB: + case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB: + case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB: case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGB_FXT1_3DFX: case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: case GL_ETC1_RGB8_OES: case GL_COMPRESSED_RGB8_ETC2: case GL_COMPRESSED_SRGB8_ETC2: + case GL_RGB_S3TC: + case GL_RGB4_S3TC: + case GL_PALETTE4_RGB8_OES: + case GL_PALETTE4_R5_G6_B5_OES: + case GL_PALETTE8_RGB8_OES: + case GL_PALETTE8_R5_G6_B5_OES: return GL_RGB; case GL_COMPRESSED_RGBA: case GL_COMPRESSED_SRGB_ALPHA: case GL_COMPRESSED_RGBA_BPTC_UNORM_ARB: case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB: - case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB: - case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: @@ -118,6 +123,14 @@ _mesa_gl_compressed_format_base_format(GLenum format) case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: + case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: + case GL_PALETTE4_RGBA8_OES: + case GL_PALETTE8_RGB5_A1_OES: + case GL_PALETTE4_RGBA4_OES: + case GL_PALETTE4_RGB5_A1_OES: + case GL_PALETTE8_RGBA8_OES: + case GL_PALETTE8_RGBA4_OES: return GL_RGBA; case GL_COMPRESSED_ALPHA: @@ -236,6 +249,12 @@ _mesa_gl_compressed_format_base_format(GLenum format) * GL_EXT_texture_compression_latc. At the very least, Catalyst 11.6 does not * expose the 3dc formats through this mechanism. * + * The spec for GL_ARB_texture_compression_bptc doesn't mention whether it + * should be included in GL_COMPRESSED_TEXTURE_FORMATS. However as it takes a + * very long time to compress the textures in this format it's probably not + * very useful as a general format where the GL will have to compress it on + * the fly. + * * \param ctx the GL context * \param formats the resulting format list (may be NULL). * @@ -244,91 +263,191 @@ _mesa_gl_compressed_format_base_format(GLenum format) GLuint _mesa_get_compressed_formats(struct gl_context *ctx, GLint *formats) { + GLint discard_formats[100]; GLuint n = 0; - if (ctx->Extensions.TDFX_texture_compression_FXT1) { - if (formats) { - formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX; - formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX; - } - else { - n += 2; - } + + if (!formats) { + formats = discard_formats; } - if (ctx->Extensions.EXT_texture_compression_s3tc) { - if (formats) { - formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - } - else { - n += 3; - } + if (_mesa_is_desktop_gl(ctx) && + ctx->Extensions.TDFX_texture_compression_FXT1) { + formats[n++] = GL_COMPRESSED_RGB_FXT1_3DFX; + formats[n++] = GL_COMPRESSED_RGBA_FXT1_3DFX; } - if (ctx->Extensions.S3_s3tc) { - if (formats) { - formats[n++] = GL_RGB_S3TC; - formats[n++] = GL_RGB4_S3TC; - formats[n++] = GL_RGBA_S3TC; - formats[n++] = GL_RGBA4_S3TC; - } - else { - n += 4; + + if (ctx->Extensions.EXT_texture_compression_s3tc) { + formats[n++] = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + + /* The ES and desktop GL specs diverge here. + * + * In desktop OpenGL, the driver can perform online compression of + * uncompressed texture data. GL_NUM_COMPRESSED_TEXTURE_FORMATS and + * GL_COMPRESSED_TEXTURE_FORMATS give the application a list of + * formats that it could ask the driver to compress with some + * expectation of quality. The GL_ARB_texture_compression spec + * calls this "suitable for general-purpose usage." As noted + * above, this means GL_COMPRESSED_RGBA_S3TC_DXT1_EXT is not + * included in the list. + * + * In OpenGL ES, the driver never performs compression. + * GL_NUM_COMPRESSED_TEXTURE_FORMATS and + * GL_COMPRESSED_TEXTURE_FORMATS give the application a list of + * formats that the driver can receive from the application. It + * is the *complete* list of formats. The + * GL_EXT_texture_compression_s3tc spec says: + * + * "New State for OpenGL ES 2.0.25 and 3.0.2 Specifications + * + * The queries for NUM_COMPRESSED_TEXTURE_FORMATS and + * COMPRESSED_TEXTURE_FORMATS include + * COMPRESSED_RGB_S3TC_DXT1_EXT, + * COMPRESSED_RGBA_S3TC_DXT1_EXT, + * COMPRESSED_RGBA_S3TC_DXT3_EXT, and + * COMPRESSED_RGBA_S3TC_DXT5_EXT." + * + * Note that the addition is only to the OpenGL ES specification! + */ + if (_mesa_is_gles(ctx)) { + formats[n++] = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; } } - if (ctx->Extensions.OES_compressed_ETC1_RGB8_texture) { - if (formats) { - formats[n++] = GL_ETC1_RGB8_OES; - } - else { - n += 1; - } + /* The GL_OES_compressed_ETC1_RGB8_texture spec says: + * + * "New State + * + * The queries for NUM_COMPRESSED_TEXTURE_FORMATS and + * COMPRESSED_TEXTURE_FORMATS include ETC1_RGB8_OES." + */ + if (_mesa_is_gles(ctx) + && ctx->Extensions.OES_compressed_ETC1_RGB8_texture) { + formats[n++] = GL_ETC1_RGB8_OES; } if (ctx->API == API_OPENGLES) { - if (formats) { - formats[n++] = GL_PALETTE4_RGB8_OES; - formats[n++] = GL_PALETTE4_RGBA8_OES; - formats[n++] = GL_PALETTE4_R5_G6_B5_OES; - formats[n++] = GL_PALETTE4_RGBA4_OES; - formats[n++] = GL_PALETTE4_RGB5_A1_OES; - formats[n++] = GL_PALETTE8_RGB8_OES; - formats[n++] = GL_PALETTE8_RGBA8_OES; - formats[n++] = GL_PALETTE8_R5_G6_B5_OES; - formats[n++] = GL_PALETTE8_RGBA4_OES; - formats[n++] = GL_PALETTE8_RGB5_A1_OES; - } - else { - n += 10; - } + formats[n++] = GL_PALETTE4_RGB8_OES; + formats[n++] = GL_PALETTE4_RGBA8_OES; + formats[n++] = GL_PALETTE4_R5_G6_B5_OES; + formats[n++] = GL_PALETTE4_RGBA4_OES; + formats[n++] = GL_PALETTE4_RGB5_A1_OES; + formats[n++] = GL_PALETTE8_RGB8_OES; + formats[n++] = GL_PALETTE8_RGBA8_OES; + formats[n++] = GL_PALETTE8_R5_G6_B5_OES; + formats[n++] = GL_PALETTE8_RGBA4_OES; + formats[n++] = GL_PALETTE8_RGB5_A1_OES; + } + + if (_mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility) { + formats[n++] = GL_COMPRESSED_RGB8_ETC2; + formats[n++] = GL_COMPRESSED_RGBA8_ETC2_EAC; + formats[n++] = GL_COMPRESSED_R11_EAC; + formats[n++] = GL_COMPRESSED_RG11_EAC; + formats[n++] = GL_COMPRESSED_SIGNED_R11_EAC; + formats[n++] = GL_COMPRESSED_SIGNED_RG11_EAC; + formats[n++] = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; } if (_mesa_is_gles3(ctx)) { - if (formats) { - formats[n++] = GL_COMPRESSED_RGB8_ETC2; - formats[n++] = GL_COMPRESSED_SRGB8_ETC2; - formats[n++] = GL_COMPRESSED_RGBA8_ETC2_EAC; - formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; - formats[n++] = GL_COMPRESSED_R11_EAC; - formats[n++] = GL_COMPRESSED_RG11_EAC; - formats[n++] = GL_COMPRESSED_SIGNED_R11_EAC; - formats[n++] = GL_COMPRESSED_SIGNED_RG11_EAC; - formats[n++] = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2; - formats[n++] = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; - } - else { - n += 10; - } + formats[n++] = GL_COMPRESSED_SRGB8_ETC2; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC; + formats[n++] = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; } + + /* The KHR_texture_compression_astc_hdr spec says: + * + * "Interactions with OpenGL 4.2 + * + * OpenGL 4.2 supports the feature that compressed textures can be + * compressed online, by passing the compressed texture format enum + * as the internal format when uploading a texture using TexImage1D, + * TexImage2D or TexImage3D (see Section 3.9.3, Texture Image + * Specification, subsection Encoding of Special Internal Formats). + * + * Due to the complexity of the ASTC compression algorithm, it is + * not usually suitable for online use, and therefore ASTC support + * will be limited to pre-compressed textures only. Where on-device + * compression is required, a domain-specific limited compressor + * will typically be used, and this is therefore not suitable for + * implementation in the driver. + * + * In particular, the ASTC format specifiers will not be added to + * Table 3.14, and thus will not be accepted by the TexImage*D + * functions, and will not be returned by the (already deprecated) + * COMPRESSED_TEXTURE_FORMATS query." + * + * The ES and the desktop specs diverge here. In OpenGL ES, the + * COMPRESSED_TEXTURE_FORMATS query returns the set of supported specific + * compressed formats. + */ + if (ctx->API == API_OPENGLES2 && + ctx->Extensions.KHR_texture_compression_astc_ldr) { + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x4_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x5_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x6_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x8_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_10x10_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_12x10_KHR; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_12x12_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR; + } + + if (_mesa_is_gles3(ctx) && + ctx->Extensions.OES_texture_compression_astc) { + formats[n++] = GL_COMPRESSED_RGBA_ASTC_3x3x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x3x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4x3_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_4x4x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x4x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5x4_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_5x5x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x5x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6x5_OES; + formats[n++] = GL_COMPRESSED_RGBA_ASTC_6x6x6_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES; + formats[n++] = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES; + } + + assert(n <= ARRAY_SIZE(discard_formats)); + return n; } /** - * Convert a compressed MESA_FORMAT_x to a GLenum. + * Convert GLenum to a compressed MESA_FORMAT_x. */ -gl_format +mesa_format _mesa_glenum_to_compressed_format(GLenum format) { switch (format) { @@ -339,15 +458,15 @@ _mesa_glenum_to_compressed_format(GLenum format) case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_RGB_S3TC: + case GL_RGB4_S3TC: return MESA_FORMAT_RGB_DXT1; case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - case GL_RGB4_S3TC: return MESA_FORMAT_RGBA_DXT1; case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_RGBA_S3TC: + case GL_RGBA4_S3TC: return MESA_FORMAT_RGBA_DXT3; case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - case GL_RGBA4_S3TC: return MESA_FORMAT_RGBA_DXT5; case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: @@ -360,23 +479,23 @@ _mesa_glenum_to_compressed_format(GLenum format) return MESA_FORMAT_SRGBA_DXT5; case GL_COMPRESSED_RED_RGTC1: - return MESA_FORMAT_RED_RGTC1; + return MESA_FORMAT_R_RGTC1_UNORM; case GL_COMPRESSED_SIGNED_RED_RGTC1: - return MESA_FORMAT_SIGNED_RED_RGTC1; + return MESA_FORMAT_R_RGTC1_SNORM; case GL_COMPRESSED_RG_RGTC2: - return MESA_FORMAT_RG_RGTC2; + return MESA_FORMAT_RG_RGTC2_UNORM; case GL_COMPRESSED_SIGNED_RG_RGTC2: - return MESA_FORMAT_SIGNED_RG_RGTC2; + return MESA_FORMAT_RG_RGTC2_SNORM; case GL_COMPRESSED_LUMINANCE_LATC1_EXT: - return MESA_FORMAT_L_LATC1; + return MESA_FORMAT_L_LATC1_UNORM; case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: - return MESA_FORMAT_SIGNED_L_LATC1; + return MESA_FORMAT_L_LATC1_SNORM; case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: - return MESA_FORMAT_LA_LATC2; + return MESA_FORMAT_LA_LATC2_UNORM; case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: - return MESA_FORMAT_SIGNED_LA_LATC2; + return MESA_FORMAT_LA_LATC2_SNORM; case GL_ETC1_RGB8_OES: return MESA_FORMAT_ETC1_RGB8; @@ -401,6 +520,112 @@ _mesa_glenum_to_compressed_format(GLenum format) case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: return MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1; + case GL_COMPRESSED_RGBA_BPTC_UNORM: + return MESA_FORMAT_BPTC_RGBA_UNORM; + case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM: + return MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM; + case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT: + return MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT; + case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: + return MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT; + + case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: + return MESA_FORMAT_RGBA_ASTC_4x4; + case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: + return MESA_FORMAT_RGBA_ASTC_5x4; + case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: + return MESA_FORMAT_RGBA_ASTC_5x5; + case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: + return MESA_FORMAT_RGBA_ASTC_6x5; + case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: + return MESA_FORMAT_RGBA_ASTC_6x6; + case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: + return MESA_FORMAT_RGBA_ASTC_8x5; + case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: + return MESA_FORMAT_RGBA_ASTC_8x6; + case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: + return MESA_FORMAT_RGBA_ASTC_8x8; + case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: + return MESA_FORMAT_RGBA_ASTC_10x5; + case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: + return MESA_FORMAT_RGBA_ASTC_10x6; + case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: + return MESA_FORMAT_RGBA_ASTC_10x8; + case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: + return MESA_FORMAT_RGBA_ASTC_10x10; + case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: + return MESA_FORMAT_RGBA_ASTC_12x10; + case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: + return MESA_FORMAT_RGBA_ASTC_12x12; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12; + case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES: + return MESA_FORMAT_RGBA_ASTC_3x3x3; + case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES: + return MESA_FORMAT_RGBA_ASTC_4x3x3; + case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES: + return MESA_FORMAT_RGBA_ASTC_4x4x3; + case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES: + return MESA_FORMAT_RGBA_ASTC_4x4x4; + case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES: + return MESA_FORMAT_RGBA_ASTC_5x4x4; + case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES: + return MESA_FORMAT_RGBA_ASTC_5x5x4; + case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES: + return MESA_FORMAT_RGBA_ASTC_5x5x5; + case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES: + return MESA_FORMAT_RGBA_ASTC_6x5x5; + case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES: + return MESA_FORMAT_RGBA_ASTC_6x6x5; + case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES: + return MESA_FORMAT_RGBA_ASTC_6x6x6; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_3x3x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x3x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x3; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x4; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x5; + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES: + return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x6; + default: return MESA_FORMAT_NONE; } @@ -418,7 +643,8 @@ _mesa_glenum_to_compressed_format(GLenum format) * internal format unchanged. */ GLenum -_mesa_compressed_format_to_glenum(struct gl_context *ctx, gl_format mesaFormat) +_mesa_compressed_format_to_glenum(struct gl_context *ctx, + mesa_format mesaFormat) { switch (mesaFormat) { case MESA_FORMAT_RGB_FXT1: @@ -441,22 +667,22 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, gl_format mesaFormat) return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT; case MESA_FORMAT_SRGBA_DXT5: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT; - case MESA_FORMAT_RED_RGTC1: + case MESA_FORMAT_R_RGTC1_UNORM: return GL_COMPRESSED_RED_RGTC1; - case MESA_FORMAT_SIGNED_RED_RGTC1: + case MESA_FORMAT_R_RGTC1_SNORM: return GL_COMPRESSED_SIGNED_RED_RGTC1; - case MESA_FORMAT_RG_RGTC2: + case MESA_FORMAT_RG_RGTC2_UNORM: return GL_COMPRESSED_RG_RGTC2; - case MESA_FORMAT_SIGNED_RG_RGTC2: + case MESA_FORMAT_RG_RGTC2_SNORM: return GL_COMPRESSED_SIGNED_RG_RGTC2; - case MESA_FORMAT_L_LATC1: + case MESA_FORMAT_L_LATC1_UNORM: return GL_COMPRESSED_LUMINANCE_LATC1_EXT; - case MESA_FORMAT_SIGNED_L_LATC1: + case MESA_FORMAT_L_LATC1_SNORM: return GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT; - case MESA_FORMAT_LA_LATC2: + case MESA_FORMAT_LA_LATC2_UNORM: return GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT; - case MESA_FORMAT_SIGNED_LA_LATC2: + case MESA_FORMAT_LA_LATC2_SNORM: return GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT; case MESA_FORMAT_ETC1_RGB8: @@ -482,6 +708,112 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, gl_format mesaFormat) case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2; + case MESA_FORMAT_BPTC_RGBA_UNORM: + return GL_COMPRESSED_RGBA_BPTC_UNORM; + case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM: + return GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM; + case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT; + case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT: + return GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT; + + case MESA_FORMAT_RGBA_ASTC_4x4: + return GL_COMPRESSED_RGBA_ASTC_4x4_KHR; + case MESA_FORMAT_RGBA_ASTC_5x4: + return GL_COMPRESSED_RGBA_ASTC_5x4_KHR; + case MESA_FORMAT_RGBA_ASTC_5x5: + return GL_COMPRESSED_RGBA_ASTC_5x5_KHR; + case MESA_FORMAT_RGBA_ASTC_6x5: + return GL_COMPRESSED_RGBA_ASTC_6x5_KHR; + case MESA_FORMAT_RGBA_ASTC_6x6: + return GL_COMPRESSED_RGBA_ASTC_6x6_KHR; + case MESA_FORMAT_RGBA_ASTC_8x5: + return GL_COMPRESSED_RGBA_ASTC_8x5_KHR; + case MESA_FORMAT_RGBA_ASTC_8x6: + return GL_COMPRESSED_RGBA_ASTC_8x6_KHR; + case MESA_FORMAT_RGBA_ASTC_8x8: + return GL_COMPRESSED_RGBA_ASTC_8x8_KHR; + case MESA_FORMAT_RGBA_ASTC_10x5: + return GL_COMPRESSED_RGBA_ASTC_10x5_KHR; + case MESA_FORMAT_RGBA_ASTC_10x6: + return GL_COMPRESSED_RGBA_ASTC_10x6_KHR; + case MESA_FORMAT_RGBA_ASTC_10x8: + return GL_COMPRESSED_RGBA_ASTC_10x8_KHR; + case MESA_FORMAT_RGBA_ASTC_10x10: + return GL_COMPRESSED_RGBA_ASTC_10x10_KHR; + case MESA_FORMAT_RGBA_ASTC_12x10: + return GL_COMPRESSED_RGBA_ASTC_12x10_KHR; + case MESA_FORMAT_RGBA_ASTC_12x12: + return GL_COMPRESSED_RGBA_ASTC_12x12_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR; + + case MESA_FORMAT_RGBA_ASTC_3x3x3: + return GL_COMPRESSED_RGBA_ASTC_3x3x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x3x3: + return GL_COMPRESSED_RGBA_ASTC_4x3x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x4x3: + return GL_COMPRESSED_RGBA_ASTC_4x4x3_OES; + case MESA_FORMAT_RGBA_ASTC_4x4x4: + return GL_COMPRESSED_RGBA_ASTC_4x4x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x4x4: + return GL_COMPRESSED_RGBA_ASTC_5x4x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x5x4: + return GL_COMPRESSED_RGBA_ASTC_5x5x4_OES; + case MESA_FORMAT_RGBA_ASTC_5x5x5: + return GL_COMPRESSED_RGBA_ASTC_5x5x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x5x5: + return GL_COMPRESSED_RGBA_ASTC_6x5x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x6x5: + return GL_COMPRESSED_RGBA_ASTC_6x6x5_OES; + case MESA_FORMAT_RGBA_ASTC_6x6x6: + return GL_COMPRESSED_RGBA_ASTC_6x6x6_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_3x3x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x3x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x3: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x4: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x5: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES; + case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x6: + return GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES; default: _mesa_problem(ctx, "Unexpected mesa texture format in" " _mesa_compressed_format_to_glenum()"); @@ -502,7 +834,7 @@ _mesa_compressed_format_to_glenum(struct gl_context *ctx, gl_format mesaFormat) */ GLubyte * _mesa_compressed_image_address(GLint col, GLint row, GLint img, - gl_format mesaFormat, + mesa_format mesaFormat, GLsizei width, const GLubyte *image) { /* XXX only 2D images implemented, not 3D */ @@ -512,8 +844,8 @@ _mesa_compressed_image_address(GLint col, GLint row, GLint img, _mesa_get_format_block_size(mesaFormat, &bw, &bh); - ASSERT(col % bw == 0); - ASSERT(row % bh == 0); + assert(col % bw == 0); + assert(row % bh == 0); offset = ((width + bw - 1) / bw) * (row / bh) + col / bw; offset *= blockSize; @@ -522,130 +854,60 @@ _mesa_compressed_image_address(GLint col, GLint row, GLint img, } +/** + * Return a texel-fetch function for the given format, or NULL if + * invalid format. + */ +compressed_fetch_func +_mesa_get_compressed_fetch_func(mesa_format format) +{ + switch (_mesa_get_format_layout(format)) { + case MESA_FORMAT_LAYOUT_S3TC: + return _mesa_get_dxt_fetch_func(format); + case MESA_FORMAT_LAYOUT_FXT1: + return _mesa_get_fxt_fetch_func(format); + case MESA_FORMAT_LAYOUT_RGTC: + case MESA_FORMAT_LAYOUT_LATC: + return _mesa_get_compressed_rgtc_func(format); + case MESA_FORMAT_LAYOUT_ETC1: + return _mesa_get_etc_fetch_func(format); + case MESA_FORMAT_LAYOUT_BPTC: + return _mesa_get_bptc_fetch_func(format); + default: + return NULL; + } +} + + /** * Decompress a compressed texture image, returning a GL_RGBA/GL_FLOAT image. * \param srcRowStride stride in bytes between rows of blocks in the * compressed source image. */ void -_mesa_decompress_image(gl_format format, GLuint width, GLuint height, +_mesa_decompress_image(mesa_format format, GLuint width, GLuint height, const GLubyte *src, GLint srcRowStride, GLfloat *dest) { - void (*fetch)(const struct swrast_texture_image *texImage, - GLint i, GLint j, GLint k, GLfloat *texel); - struct swrast_texture_image texImage; /* dummy teximage */ + compressed_fetch_func fetch; GLuint i, j; GLuint bytes, bw, bh; + GLint stride; bytes = _mesa_get_format_bytes(format); _mesa_get_format_block_size(format, &bw, &bh); - /* setup dummy texture image info */ - memset(&texImage, 0, sizeof(texImage)); - texImage.Map = (void *) src; - - /* XXX This line is a bit of a hack to adapt to the row stride - * convention used by the texture decompression functions. - */ - texImage.RowStride = srcRowStride * bh / bytes; - - switch (format) { - /* DXT formats */ - case MESA_FORMAT_RGB_DXT1: - fetch = _mesa_fetch_texel_rgb_dxt1; - break; - case MESA_FORMAT_RGBA_DXT1: - fetch = _mesa_fetch_texel_rgba_dxt1; - break; - case MESA_FORMAT_RGBA_DXT3: - fetch = _mesa_fetch_texel_rgba_dxt3; - break; - case MESA_FORMAT_RGBA_DXT5: - fetch = _mesa_fetch_texel_rgba_dxt5; - break; - - /* FXT1 formats */ - case MESA_FORMAT_RGB_FXT1: - fetch = _mesa_fetch_texel_2d_f_rgb_fxt1; - break; - case MESA_FORMAT_RGBA_FXT1: - fetch = _mesa_fetch_texel_2d_f_rgba_fxt1; - break; - - /* Red/RG formats */ - case MESA_FORMAT_RED_RGTC1: - fetch = _mesa_fetch_texel_red_rgtc1; - break; - case MESA_FORMAT_SIGNED_RED_RGTC1: - fetch = _mesa_fetch_texel_signed_red_rgtc1; - break; - case MESA_FORMAT_RG_RGTC2: - fetch = _mesa_fetch_texel_rg_rgtc2; - break; - case MESA_FORMAT_SIGNED_RG_RGTC2: - fetch = _mesa_fetch_texel_signed_rg_rgtc2; - break; - - /* L/LA formats */ - case MESA_FORMAT_L_LATC1: - fetch = _mesa_fetch_texel_l_latc1; - break; - case MESA_FORMAT_SIGNED_L_LATC1: - fetch = _mesa_fetch_texel_signed_l_latc1; - break; - case MESA_FORMAT_LA_LATC2: - fetch = _mesa_fetch_texel_la_latc2; - break; - case MESA_FORMAT_SIGNED_LA_LATC2: - fetch = _mesa_fetch_texel_signed_la_latc2; - break; - - /* ETC1 formats */ - case MESA_FORMAT_ETC1_RGB8: - fetch = _mesa_fetch_texel_2d_f_etc1_rgb8; - break; - - /* ETC2 formats */ - case MESA_FORMAT_ETC2_RGB8: - fetch = _mesa_fetch_texel_2d_f_etc2_rgb8; - break; - case MESA_FORMAT_ETC2_SRGB8: - fetch = _mesa_fetch_texel_2d_f_etc2_srgb8; - break; - case MESA_FORMAT_ETC2_RGBA8_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_rgba8_eac; - break; - case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_srgb8_alpha8_eac; - break; - case MESA_FORMAT_ETC2_R11_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_r11_eac; - break; - case MESA_FORMAT_ETC2_RG11_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_rg11_eac; - break; - case MESA_FORMAT_ETC2_SIGNED_R11_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_signed_r11_eac; - break; - case MESA_FORMAT_ETC2_SIGNED_RG11_EAC: - fetch = _mesa_fetch_texel_2d_f_etc2_signed_rg11_eac; - break; - case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: - /* fetch = _mesa_fetch_texel_2d_f_etc2_rgb8_punchthrough_alpha1; -- not implemented yet */ - break; - case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: - /* fetch = _mesa_fetch_texel_2d_f_etc2_srgb8_punchthrough_alpha1; -- not implemented yet */ - break; - - default: + fetch = _mesa_get_compressed_fetch_func(format); + if (!fetch) { _mesa_problem(NULL, "Unexpected format in _mesa_decompress_image()"); return; } + stride = srcRowStride * bh / bytes; + for (j = 0; j < height; j++) { for (i = 0; i < width; i++) { - fetch(&texImage, i, j, 0, dest); + fetch(src, stride, i, j, dest); dest += 4; } }