/* * Mesa 3-D graphics library * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * Copyright (c) 2008-2009 VMware, Inc. * Copyright (c) 2012 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * 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 * 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. */ #include "context.h" #include "glformats.h" #include "formats.h" #include "texcompress.h" #include "enums.h" enum { ZERO = 4, ONE = 5 }; enum { IDX_LUMINANCE = 0, IDX_ALPHA, IDX_INTENSITY, IDX_LUMINANCE_ALPHA, IDX_RGB, IDX_RGBA, IDX_RED, IDX_GREEN, IDX_BLUE, IDX_BGR, IDX_BGRA, IDX_ABGR, IDX_RG, MAX_IDX }; #define MAP1(x) MAP4(x, ZERO, ZERO, ZERO) #define MAP2(x,y) MAP4(x, y, ZERO, ZERO) #define MAP3(x,y,z) MAP4(x, y, z, ZERO) #define MAP4(x,y,z,w) { x, y, z, w, ZERO, ONE } static const struct { GLubyte format_idx; GLubyte to_rgba[6]; GLubyte from_rgba[6]; } mappings[MAX_IDX] = { { IDX_LUMINANCE, MAP4(0,0,0,ONE), MAP1(0) }, { IDX_ALPHA, MAP4(ZERO, ZERO, ZERO, 0), MAP1(3) }, { IDX_INTENSITY, MAP4(0, 0, 0, 0), MAP1(0), }, { IDX_LUMINANCE_ALPHA, MAP4(0,0,0,1), MAP2(0,3) }, { IDX_RGB, MAP4(0,1,2,ONE), MAP3(0,1,2) }, { IDX_RGBA, MAP4(0,1,2,3), MAP4(0,1,2,3), }, { IDX_RED, MAP4(0, ZERO, ZERO, ONE), MAP1(0), }, { IDX_GREEN, MAP4(ZERO, 0, ZERO, ONE), MAP1(1), }, { IDX_BLUE, MAP4(ZERO, ZERO, 0, ONE), MAP1(2), }, { IDX_BGR, MAP4(2,1,0,ONE), MAP3(2,1,0) }, { IDX_BGRA, MAP4(2,1,0,3), MAP4(2,1,0,3) }, { IDX_ABGR, MAP4(3,2,1,0), MAP4(3,2,1,0) }, { IDX_RG, MAP4(0, 1, ZERO, ONE), MAP2(0, 1) }, }; /** * Convert a GL image format enum to an IDX_* value (see above). */ static int get_map_idx(GLenum value) { switch (value) { case GL_LUMINANCE: case GL_LUMINANCE_INTEGER_EXT: return IDX_LUMINANCE; case GL_ALPHA: case GL_ALPHA_INTEGER: return IDX_ALPHA; case GL_INTENSITY: return IDX_INTENSITY; case GL_LUMINANCE_ALPHA: case GL_LUMINANCE_ALPHA_INTEGER_EXT: return IDX_LUMINANCE_ALPHA; case GL_RGB: case GL_RGB_INTEGER: return IDX_RGB; case GL_RGBA: case GL_RGBA_INTEGER: return IDX_RGBA; case GL_RED: case GL_RED_INTEGER: return IDX_RED; case GL_GREEN: return IDX_GREEN; case GL_BLUE: return IDX_BLUE; case GL_BGR: case GL_BGR_INTEGER: return IDX_BGR; case GL_BGRA: case GL_BGRA_INTEGER: return IDX_BGRA; case GL_ABGR_EXT: return IDX_ABGR; case GL_RG: case GL_RG_INTEGER: return IDX_RG; default: _mesa_problem(NULL, "Unexpected inFormat %s", _mesa_enum_to_string(value)); return 0; } } /** * When promoting texture formats (see below) we need to compute the * mapping of dest components back to source components. * This function does that. * \param inFormat the incoming format of the texture * \param outFormat the final texture format * \return map[6] a full 6-component map */ void _mesa_compute_component_mapping(GLenum inFormat, GLenum outFormat, GLubyte *map) { const int inFmt = get_map_idx(inFormat); const int outFmt = get_map_idx(outFormat); const GLubyte *in2rgba = mappings[inFmt].to_rgba; const GLubyte *rgba2out = mappings[outFmt].from_rgba; int i; for (i = 0; i < 4; i++) map[i] = in2rgba[rgba2out[i]]; map[ZERO] = ZERO; map[ONE] = ONE; #if 0 printf("from %x/%s to %x/%s map %d %d %d %d %d %d\n", inFormat, _mesa_enum_to_string(inFormat), outFormat, _mesa_enum_to_string(outFormat), map[0], map[1], map[2], map[3], map[4], map[5]); #endif } /** * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. */ GLboolean _mesa_type_is_packed(GLenum type) { switch (type) { case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: case MESA_UNSIGNED_BYTE_4_4: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: case GL_UNSIGNED_SHORT_8_8_MESA: case GL_UNSIGNED_SHORT_8_8_REV_MESA: case GL_UNSIGNED_INT_24_8_EXT: case GL_UNSIGNED_INT_5_9_9_9_REV: case GL_UNSIGNED_INT_10F_11F_11F_REV: case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return GL_TRUE; } return GL_FALSE; } /** * Get the size of a GL data type. * * \param type GL data type. * * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 * if an invalid type enum. */ GLint _mesa_sizeof_type(GLenum type) { switch (type) { case GL_BITMAP: return 0; case GL_UNSIGNED_BYTE: return sizeof(GLubyte); case GL_BYTE: return sizeof(GLbyte); case GL_UNSIGNED_SHORT: return sizeof(GLushort); case GL_SHORT: return sizeof(GLshort); case GL_UNSIGNED_INT: return sizeof(GLuint); case GL_INT: return sizeof(GLint); case GL_FLOAT: return sizeof(GLfloat); case GL_DOUBLE: return sizeof(GLdouble); case GL_HALF_FLOAT_ARB: case GL_HALF_FLOAT_OES: return sizeof(GLhalfARB); case GL_FIXED: return sizeof(GLfixed); default: return -1; } } /** * Same as _mesa_sizeof_type() but also accepting the packed pixel * format data types. */ GLint _mesa_sizeof_packed_type(GLenum type) { switch (type) { case GL_BITMAP: return 0; case GL_UNSIGNED_BYTE: return sizeof(GLubyte); case GL_BYTE: return sizeof(GLbyte); case GL_UNSIGNED_SHORT: return sizeof(GLushort); case GL_SHORT: return sizeof(GLshort); case GL_UNSIGNED_INT: return sizeof(GLuint); case GL_INT: return sizeof(GLint); case GL_HALF_FLOAT_ARB: case GL_HALF_FLOAT_OES: return sizeof(GLhalfARB); case GL_FLOAT: return sizeof(GLfloat); case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: case MESA_UNSIGNED_BYTE_4_4: return sizeof(GLubyte); case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_SHORT_8_8_MESA: case GL_UNSIGNED_SHORT_8_8_REV_MESA: return sizeof(GLushort); case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: case GL_UNSIGNED_INT_24_8_EXT: case GL_UNSIGNED_INT_5_9_9_9_REV: case GL_UNSIGNED_INT_10F_11F_11F_REV: return sizeof(GLuint); case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: return 8; default: return -1; } } /** * Get the number of components in a pixel format. * * \param format pixel format. * * \return the number of components in the given format, or -1 if a bad format. */ GLint _mesa_components_in_format(GLenum format) { switch (format) { case GL_COLOR_INDEX: case GL_STENCIL_INDEX: case GL_DEPTH_COMPONENT: case GL_RED: case GL_RED_INTEGER_EXT: case GL_GREEN: case GL_GREEN_INTEGER_EXT: case GL_BLUE: case GL_BLUE_INTEGER_EXT: case GL_ALPHA: case GL_ALPHA_INTEGER_EXT: case GL_LUMINANCE: case GL_LUMINANCE_INTEGER_EXT: case GL_INTENSITY: return 1; case GL_LUMINANCE_ALPHA: case GL_LUMINANCE_ALPHA_INTEGER_EXT: case GL_RG: case GL_YCBCR_MESA: case GL_DEPTH_STENCIL_EXT: case GL_RG_INTEGER: return 2; case GL_RGB: case GL_BGR: case GL_RGB_INTEGER_EXT: case GL_BGR_INTEGER_EXT: return 3; case GL_RGBA: case GL_BGRA: case GL_ABGR_EXT: case GL_RGBA_INTEGER_EXT: case GL_BGRA_INTEGER_EXT: return 4; default: return -1; } } /** * Get the bytes per pixel of pixel format type pair. * * \param format pixel format. * \param type pixel type. * * \return bytes per pixel, or -1 if a bad format or type was given. */ GLint _mesa_bytes_per_pixel(GLenum format, GLenum type) { GLint comps = _mesa_components_in_format(format); if (comps < 0) return -1; switch (type) { case GL_BITMAP: return 0; /* special case */ case GL_BYTE: case GL_UNSIGNED_BYTE: return comps * sizeof(GLubyte); case GL_SHORT: case GL_UNSIGNED_SHORT: return comps * sizeof(GLshort); case GL_INT: case GL_UNSIGNED_INT: return comps * sizeof(GLint); case GL_FLOAT: return comps * sizeof(GLfloat); case GL_HALF_FLOAT_ARB: case GL_HALF_FLOAT_OES: return comps * sizeof(GLhalfARB); case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: if (format == GL_RGB || format == GL_BGR || format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) return sizeof(GLubyte); else return -1; /* error */ case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: if (format == GL_RGB || format == GL_BGR || format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) return sizeof(GLushort); else return -1; /* error */ case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) return sizeof(GLushort); else return -1; case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: if (format == GL_RGBA || format == GL_BGRA || format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) return sizeof(GLushort); else return -1; case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT || format == GL_RGB) return sizeof(GLuint); else return -1; case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: if (format == GL_RGBA || format == GL_BGRA || format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT || format == GL_RGB) return sizeof(GLuint); else return -1; case GL_UNSIGNED_SHORT_8_8_MESA: case GL_UNSIGNED_SHORT_8_8_REV_MESA: if (format == GL_YCBCR_MESA) return sizeof(GLushort); else return -1; case GL_UNSIGNED_INT_24_8_EXT: if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) return sizeof(GLuint); else return -1; case GL_UNSIGNED_INT_5_9_9_9_REV: if (format == GL_RGB) return sizeof(GLuint); else return -1; case GL_UNSIGNED_INT_10F_11F_11F_REV: if (format == GL_RGB) return sizeof(GLuint); else return -1; case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: if (format == GL_DEPTH_STENCIL) return 8; else return -1; default: return -1; } } /** * Get the number of bytes for a vertex attrib with the given number of * components and type. * * \param comps number of components. * \param type data type. * * \return bytes per attribute, or -1 if a bad comps/type combination was given. */ GLint _mesa_bytes_per_vertex_attrib(GLint comps, GLenum type) { switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: return comps * sizeof(GLubyte); case GL_SHORT: case GL_UNSIGNED_SHORT: return comps * sizeof(GLshort); case GL_INT: case GL_UNSIGNED_INT: return comps * sizeof(GLint); case GL_FLOAT: return comps * sizeof(GLfloat); case GL_HALF_FLOAT_ARB: return comps * sizeof(GLhalfARB); case GL_DOUBLE: return comps * sizeof(GLdouble); case GL_FIXED: return comps * sizeof(GLfixed); case GL_INT_2_10_10_10_REV: case GL_UNSIGNED_INT_2_10_10_10_REV: if (comps == 4) return sizeof(GLuint); else return -1; case GL_UNSIGNED_INT_10F_11F_11F_REV: if (comps == 3) return sizeof(GLuint); else return -1; default: return -1; } } /** * Test if the given format is unsized. */ GLboolean _mesa_is_enum_format_unsized(GLenum format) { switch (format) { case GL_RGBA: case GL_BGRA: case GL_ABGR_EXT: case GL_RGB: case GL_BGR: case GL_RG: case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: case GL_INTENSITY: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_SRGB: case GL_SRGB_ALPHA: case GL_SLUMINANCE: case GL_SLUMINANCE_ALPHA: case GL_RGBA_SNORM: case GL_RGB_SNORM: case GL_RG_SNORM: case GL_RED_SNORM: case GL_ALPHA_SNORM: case GL_INTENSITY_SNORM: case GL_LUMINANCE_SNORM: case GL_LUMINANCE_ALPHA_SNORM: case GL_RED_INTEGER: case GL_GREEN_INTEGER: case GL_BLUE_INTEGER: case GL_ALPHA_INTEGER: case GL_RGB_INTEGER: case GL_RGBA_INTEGER: case GL_BGR_INTEGER: case GL_BGRA_INTEGER: case GL_RG_INTEGER: case GL_LUMINANCE_INTEGER_EXT: case GL_LUMINANCE_ALPHA_INTEGER_EXT: case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL: case GL_STENCIL_INDEX: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given format is a UNORM (unsigned-normalized) format. */ GLboolean _mesa_is_enum_format_unorm(GLenum format) { switch(format) { case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: case GL_ALPHA4: case GL_ALPHA8: case GL_ALPHA12: case GL_ALPHA16: case 1: case GL_LUMINANCE: case GL_SLUMINANCE: case GL_LUMINANCE4: case GL_LUMINANCE8: case GL_LUMINANCE12: case GL_LUMINANCE16: case 2: case GL_LUMINANCE_ALPHA: case GL_SLUMINANCE_ALPHA: case GL_LUMINANCE4_ALPHA4: case GL_LUMINANCE6_ALPHA2: case GL_LUMINANCE8_ALPHA8: case GL_LUMINANCE12_ALPHA4: case GL_LUMINANCE12_ALPHA12: case GL_LUMINANCE16_ALPHA16: case GL_INTENSITY: case GL_INTENSITY4: case GL_INTENSITY8: case GL_INTENSITY12: case GL_INTENSITY16: case GL_R8: case GL_R16: case GL_RG: case GL_RG8: case GL_RG16: case 3: case GL_RGB: case GL_BGR: case GL_SRGB: case GL_R3_G3_B2: case GL_RGB4: case GL_RGB5: case GL_RGB565: case GL_RGB8: case GL_RGB10: case GL_RGB12: case GL_RGB16: case 4: case GL_ABGR_EXT: case GL_RGBA: case GL_BGRA: case GL_SRGB_ALPHA: case GL_RGBA2: case GL_RGBA4: case GL_RGB5_A1: case GL_RGBA8: case GL_RGB10_A2: case GL_RGBA12: case GL_RGBA16: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given format is a SNORM (signed-normalized) format. */ GLboolean _mesa_is_enum_format_snorm(GLenum format) { switch (format) { /* signed, normalized texture formats */ case GL_RED_SNORM: case GL_R8_SNORM: case GL_R16_SNORM: case GL_RG_SNORM: case GL_RG8_SNORM: case GL_RG16_SNORM: case GL_RGB_SNORM: case GL_RGB8_SNORM: case GL_RGB16_SNORM: case GL_RGBA_SNORM: case GL_RGBA8_SNORM: case GL_RGBA16_SNORM: case GL_ALPHA_SNORM: case GL_ALPHA8_SNORM: case GL_ALPHA16_SNORM: case GL_LUMINANCE_SNORM: case GL_LUMINANCE8_SNORM: case GL_LUMINANCE16_SNORM: case GL_LUMINANCE_ALPHA_SNORM: case GL_LUMINANCE8_ALPHA8_SNORM: case GL_LUMINANCE16_ALPHA16_SNORM: case GL_INTENSITY_SNORM: case GL_INTENSITY8_SNORM: case GL_INTENSITY16_SNORM: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given format is an integer (non-normalized) format. */ GLboolean _mesa_is_enum_format_unsigned_int(GLenum format) { switch (format) { /* specific integer formats */ case GL_RGBA32UI_EXT: case GL_RGB32UI_EXT: case GL_RG32UI: case GL_R32UI: case GL_ALPHA32UI_EXT: case GL_INTENSITY32UI_EXT: case GL_LUMINANCE32UI_EXT: case GL_LUMINANCE_ALPHA32UI_EXT: case GL_RGBA16UI_EXT: case GL_RGB16UI_EXT: case GL_RG16UI: case GL_R16UI: case GL_ALPHA16UI_EXT: case GL_INTENSITY16UI_EXT: case GL_LUMINANCE16UI_EXT: case GL_LUMINANCE_ALPHA16UI_EXT: case GL_RGBA8UI_EXT: case GL_RGB8UI_EXT: case GL_RG8UI: case GL_R8UI: case GL_ALPHA8UI_EXT: case GL_INTENSITY8UI_EXT: case GL_LUMINANCE8UI_EXT: case GL_LUMINANCE_ALPHA8UI_EXT: case GL_RGB10_A2UI: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given format is an integer (non-normalized) format. */ GLboolean _mesa_is_enum_format_signed_int(GLenum format) { switch (format) { /* generic integer formats */ case GL_RED_INTEGER_EXT: case GL_GREEN_INTEGER_EXT: case GL_BLUE_INTEGER_EXT: case GL_ALPHA_INTEGER_EXT: case GL_RGB_INTEGER_EXT: case GL_RGBA_INTEGER_EXT: case GL_BGR_INTEGER_EXT: case GL_BGRA_INTEGER_EXT: case GL_LUMINANCE_INTEGER_EXT: case GL_LUMINANCE_ALPHA_INTEGER_EXT: case GL_RG_INTEGER: /* specific integer formats */ case GL_RGBA32I_EXT: case GL_RGB32I_EXT: case GL_RG32I: case GL_R32I: case GL_ALPHA32I_EXT: case GL_INTENSITY32I_EXT: case GL_LUMINANCE32I_EXT: case GL_LUMINANCE_ALPHA32I_EXT: case GL_RGBA16I_EXT: case GL_RGB16I_EXT: case GL_RG16I: case GL_R16I: case GL_ALPHA16I_EXT: case GL_INTENSITY16I_EXT: case GL_LUMINANCE16I_EXT: case GL_LUMINANCE_ALPHA16I_EXT: case GL_RGBA8I_EXT: case GL_RGB8I_EXT: case GL_RG8I: case GL_R8I: case GL_ALPHA8I_EXT: case GL_INTENSITY8I_EXT: case GL_LUMINANCE8I_EXT: case GL_LUMINANCE_ALPHA8I_EXT: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given format is an ASTC format. */ GLboolean _mesa_is_astc_format(GLenum internalFormat) { switch (internalFormat) { case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: return true; default: return false; } } /** * Test if the given format is an integer (non-normalized) format. */ GLboolean _mesa_is_enum_format_integer(GLenum format) { return _mesa_is_enum_format_unsigned_int(format) || _mesa_is_enum_format_signed_int(format); } GLboolean _mesa_is_type_unsigned(GLenum type) { switch (type) { case GL_UNSIGNED_INT: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_SHORT_8_8_MESA: case GL_UNSIGNED_SHORT_8_8_REV_MESA: case GL_UNSIGNED_BYTE: case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given image format is a color/RGBA format (i.e., not color * index, depth, stencil, etc). * \param format the image format value (may by an internal texture format) * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. */ GLboolean _mesa_is_color_format(GLenum format) { switch (format) { case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: case GL_ALPHA4: case GL_ALPHA8: case GL_ALPHA12: case GL_ALPHA16: case 1: case GL_LUMINANCE: case GL_LUMINANCE4: case GL_LUMINANCE8: case GL_LUMINANCE12: case GL_LUMINANCE16: case 2: case GL_LUMINANCE_ALPHA: case GL_LUMINANCE4_ALPHA4: case GL_LUMINANCE6_ALPHA2: case GL_LUMINANCE8_ALPHA8: case GL_LUMINANCE12_ALPHA4: case GL_LUMINANCE12_ALPHA12: case GL_LUMINANCE16_ALPHA16: case GL_INTENSITY: case GL_INTENSITY4: case GL_INTENSITY8: case GL_INTENSITY12: case GL_INTENSITY16: case GL_R8: case GL_R16: case GL_RG: case GL_RG8: case GL_RG16: case 3: case GL_RGB: case GL_BGR: case GL_R3_G3_B2: case GL_RGB4: case GL_RGB5: case GL_RGB565: case GL_RGB8: case GL_RGB10: case GL_RGB12: case GL_RGB16: case 4: case GL_ABGR_EXT: case GL_RGBA: case GL_BGRA: case GL_RGBA2: case GL_RGBA4: case GL_RGB5_A1: case GL_RGBA8: case GL_RGB10_A2: case GL_RGBA12: case GL_RGBA16: /* float texture formats */ case GL_ALPHA16F_ARB: case GL_ALPHA32F_ARB: case GL_LUMINANCE16F_ARB: case GL_LUMINANCE32F_ARB: case GL_LUMINANCE_ALPHA16F_ARB: case GL_LUMINANCE_ALPHA32F_ARB: case GL_INTENSITY16F_ARB: case GL_INTENSITY32F_ARB: case GL_R16F: case GL_R32F: case GL_RG16F: case GL_RG32F: case GL_RGB16F_ARB: case GL_RGB32F_ARB: case GL_RGBA16F_ARB: case GL_RGBA32F_ARB: /* compressed formats */ case GL_COMPRESSED_ALPHA: case GL_COMPRESSED_LUMINANCE: case GL_COMPRESSED_LUMINANCE_ALPHA: case GL_COMPRESSED_INTENSITY: case GL_COMPRESSED_RED: case GL_COMPRESSED_RG: case GL_COMPRESSED_RGB: case GL_COMPRESSED_RGBA: case GL_RGB_S3TC: case GL_RGB4_S3TC: case GL_RGBA_S3TC: case GL_RGBA4_S3TC: case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: case GL_COMPRESSED_RGB_FXT1_3DFX: case GL_COMPRESSED_RGBA_FXT1_3DFX: case GL_SRGB_EXT: case GL_SRGB8_EXT: case GL_SRGB_ALPHA_EXT: case GL_SRGB8_ALPHA8_EXT: case GL_SLUMINANCE_ALPHA_EXT: case GL_SLUMINANCE8_ALPHA8_EXT: case GL_SLUMINANCE_EXT: case GL_SLUMINANCE8_EXT: case GL_COMPRESSED_SRGB_EXT: case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: case GL_COMPRESSED_SRGB_ALPHA_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: case GL_COMPRESSED_SLUMINANCE_EXT: case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: case GL_COMPRESSED_RED_RGTC1: case GL_COMPRESSED_SIGNED_RED_RGTC1: case GL_COMPRESSED_RG_RGTC2: case GL_COMPRESSED_SIGNED_RG_RGTC2: case GL_COMPRESSED_LUMINANCE_LATC1_EXT: case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: case GL_ETC1_RGB8_OES: case GL_COMPRESSED_RGB8_ETC2: case GL_COMPRESSED_SRGB8_ETC2: case GL_COMPRESSED_RGBA8_ETC2_EAC: case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: case GL_COMPRESSED_R11_EAC: case GL_COMPRESSED_RG11_EAC: case GL_COMPRESSED_SIGNED_R11_EAC: case GL_COMPRESSED_SIGNED_RG11_EAC: case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: case GL_COMPRESSED_RGBA_BPTC_UNORM: case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM: case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT: case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT: case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: /* generic integer formats */ case GL_RED_INTEGER_EXT: case GL_GREEN_INTEGER_EXT: case GL_BLUE_INTEGER_EXT: case GL_ALPHA_INTEGER_EXT: case GL_RGB_INTEGER_EXT: case GL_RGBA_INTEGER_EXT: case GL_BGR_INTEGER_EXT: case GL_BGRA_INTEGER_EXT: case GL_RG_INTEGER: case GL_LUMINANCE_INTEGER_EXT: case GL_LUMINANCE_ALPHA_INTEGER_EXT: /* sized integer formats */ case GL_RGBA32UI_EXT: case GL_RGB32UI_EXT: case GL_RG32UI: case GL_R32UI: case GL_ALPHA32UI_EXT: case GL_INTENSITY32UI_EXT: case GL_LUMINANCE32UI_EXT: case GL_LUMINANCE_ALPHA32UI_EXT: case GL_RGBA16UI_EXT: case GL_RGB16UI_EXT: case GL_RG16UI: case GL_R16UI: case GL_ALPHA16UI_EXT: case GL_INTENSITY16UI_EXT: case GL_LUMINANCE16UI_EXT: case GL_LUMINANCE_ALPHA16UI_EXT: case GL_RGBA8UI_EXT: case GL_RGB8UI_EXT: case GL_RG8UI: case GL_R8UI: case GL_ALPHA8UI_EXT: case GL_INTENSITY8UI_EXT: case GL_LUMINANCE8UI_EXT: case GL_LUMINANCE_ALPHA8UI_EXT: case GL_RGBA32I_EXT: case GL_RGB32I_EXT: case GL_RG32I: case GL_R32I: case GL_ALPHA32I_EXT: case GL_INTENSITY32I_EXT: case GL_LUMINANCE32I_EXT: case GL_LUMINANCE_ALPHA32I_EXT: case GL_RGBA16I_EXT: case GL_RGB16I_EXT: case GL_RG16I: case GL_R16I: case GL_ALPHA16I_EXT: case GL_INTENSITY16I_EXT: case GL_LUMINANCE16I_EXT: case GL_LUMINANCE_ALPHA16I_EXT: case GL_RGBA8I_EXT: case GL_RGB8I_EXT: case GL_RG8I: case GL_R8I: case GL_ALPHA8I_EXT: case GL_INTENSITY8I_EXT: case GL_LUMINANCE8I_EXT: case GL_LUMINANCE_ALPHA8I_EXT: /* signed, normalized texture formats */ case GL_RED_SNORM: case GL_R8_SNORM: case GL_R16_SNORM: case GL_RG_SNORM: case GL_RG8_SNORM: case GL_RG16_SNORM: case GL_RGB_SNORM: case GL_RGB8_SNORM: case GL_RGB16_SNORM: case GL_RGBA_SNORM: case GL_RGBA8_SNORM: case GL_RGBA16_SNORM: case GL_ALPHA_SNORM: case GL_ALPHA8_SNORM: case GL_ALPHA16_SNORM: case GL_LUMINANCE_SNORM: case GL_LUMINANCE8_SNORM: case GL_LUMINANCE16_SNORM: case GL_LUMINANCE_ALPHA_SNORM: case GL_LUMINANCE8_ALPHA8_SNORM: case GL_LUMINANCE16_ALPHA16_SNORM: case GL_INTENSITY_SNORM: case GL_INTENSITY8_SNORM: case GL_INTENSITY16_SNORM: case GL_RGB9_E5: case GL_R11F_G11F_B10F: case GL_RGB10_A2UI: return GL_TRUE; case GL_YCBCR_MESA: /* not considered to be RGB */ /* fall-through */ default: return GL_FALSE; } } /** * Test if the given image format is a depth component format. */ GLboolean _mesa_is_depth_format(GLenum format) { switch (format) { case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT24: case GL_DEPTH_COMPONENT32: case GL_DEPTH_COMPONENT32F: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given image format is a stencil format. */ GLboolean _mesa_is_stencil_format(GLenum format) { switch (format) { case GL_STENCIL_INDEX: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given image format is a YCbCr format. */ GLboolean _mesa_is_ycbcr_format(GLenum format) { switch (format) { case GL_YCBCR_MESA: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given image format is a depth+stencil format. */ GLboolean _mesa_is_depthstencil_format(GLenum format) { switch (format) { case GL_DEPTH24_STENCIL8_EXT: case GL_DEPTH_STENCIL_EXT: case GL_DEPTH32F_STENCIL8: return GL_TRUE; default: return GL_FALSE; } } /** * Test if the given image format is a depth or stencil format. */ GLboolean _mesa_is_depth_or_stencil_format(GLenum format) { switch (format) { case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT24: case GL_DEPTH_COMPONENT32: case GL_STENCIL_INDEX: case GL_STENCIL_INDEX1_EXT: case GL_STENCIL_INDEX4_EXT: case GL_STENCIL_INDEX8_EXT: case GL_STENCIL_INDEX16_EXT: case GL_DEPTH_STENCIL_EXT: case GL_DEPTH24_STENCIL8_EXT: case GL_DEPTH_COMPONENT32F: case GL_DEPTH32F_STENCIL8: return GL_TRUE; default: return GL_FALSE; } } /** * Test if an image format is a supported compressed format. * \param format the internal format token provided by the user. * \return GL_TRUE if compressed, GL_FALSE if uncompressed */ GLboolean _mesa_is_compressed_format(const struct gl_context *ctx, GLenum format) { mesa_format m_format = _mesa_glenum_to_compressed_format(format); /* Some formats in this switch have an equivalent mesa_format_layout * to the compressed formats in the layout switch below and thus * must be handled first. */ switch (format) { case GL_RGB_S3TC: case GL_RGB4_S3TC: case GL_RGBA_S3TC: case GL_RGBA4_S3TC: return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ANGLE_texture_compression_dxt; case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.ATI_texture_compression_3dc; case GL_PALETTE4_RGB8_OES: case GL_PALETTE4_RGBA8_OES: case GL_PALETTE4_R5_G6_B5_OES: case GL_PALETTE4_RGBA4_OES: case GL_PALETTE4_RGB5_A1_OES: case GL_PALETTE8_RGB8_OES: case GL_PALETTE8_RGBA8_OES: case GL_PALETTE8_R5_G6_B5_OES: case GL_PALETTE8_RGBA4_OES: case GL_PALETTE8_RGB5_A1_OES: return ctx->API == API_OPENGLES; } switch (_mesa_get_format_layout(m_format)) { case MESA_FORMAT_LAYOUT_S3TC: if (_mesa_get_format_color_encoding(m_format) == GL_LINEAR) { /* Assume that the ANGLE flag will always be set if the * EXT flag is set. */ return ctx->Extensions.ANGLE_texture_compression_dxt; } else { return _mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_sRGB && ctx->Extensions.EXT_texture_compression_s3tc; } case MESA_FORMAT_LAYOUT_FXT1: return _mesa_is_desktop_gl(ctx) && ctx->Extensions.TDFX_texture_compression_FXT1; case MESA_FORMAT_LAYOUT_RGTC: return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_compression_rgtc; case MESA_FORMAT_LAYOUT_LATC: return ctx->API == API_OPENGL_COMPAT && ctx->Extensions.EXT_texture_compression_latc; case MESA_FORMAT_LAYOUT_ETC1: return _mesa_is_gles(ctx) && ctx->Extensions.OES_compressed_ETC1_RGB8_texture; case MESA_FORMAT_LAYOUT_ETC2: return _mesa_is_gles3(ctx) || ctx->Extensions.ARB_ES3_compatibility; case MESA_FORMAT_LAYOUT_BPTC: return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_compression_bptc; case MESA_FORMAT_LAYOUT_ASTC: return ctx->Extensions.KHR_texture_compression_astc_ldr; default: return GL_FALSE; } } /** * Convert various unpack formats to the corresponding base format. */ GLenum _mesa_unpack_format_to_base_format(GLenum format) { switch(format) { case GL_RED_INTEGER: return GL_RED; case GL_GREEN_INTEGER: return GL_GREEN; case GL_BLUE_INTEGER: return GL_BLUE; case GL_ALPHA_INTEGER: return GL_ALPHA; case GL_RG_INTEGER: return GL_RG; case GL_RGB_INTEGER: return GL_RGB; case GL_RGBA_INTEGER: return GL_RGBA; case GL_BGR_INTEGER: return GL_BGR; case GL_BGRA_INTEGER: return GL_BGRA; case GL_LUMINANCE_INTEGER_EXT: return GL_LUMINANCE; case GL_LUMINANCE_ALPHA_INTEGER_EXT: return GL_LUMINANCE_ALPHA; case GL_RED: case GL_GREEN: case GL_BLUE: case GL_RG: case GL_RGB: case GL_RGBA: case GL_BGR: case GL_BGRA: case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: default: return format; } } /** * Convert various base formats to the corresponding integer format. */ GLenum _mesa_base_format_to_integer_format(GLenum format) { switch(format) { case GL_RED: return GL_RED_INTEGER; case GL_GREEN: return GL_GREEN_INTEGER; case GL_BLUE: return GL_BLUE_INTEGER; case GL_RG: return GL_RG_INTEGER; case GL_RGB: return GL_RGB_INTEGER; case GL_RGBA: return GL_RGBA_INTEGER; case GL_BGR: return GL_BGR_INTEGER; case GL_BGRA: return GL_BGRA_INTEGER; case GL_ALPHA: return GL_ALPHA_INTEGER; case GL_LUMINANCE: return GL_LUMINANCE_INTEGER_EXT; case GL_LUMINANCE_ALPHA: return GL_LUMINANCE_ALPHA_INTEGER_EXT; } return format; } /** * Does the given base texture/renderbuffer format have the channel * named by 'pname'? */ GLboolean _mesa_base_format_has_channel(GLenum base_format, GLenum pname) { switch (pname) { case GL_TEXTURE_RED_SIZE: case GL_TEXTURE_RED_TYPE: case GL_RENDERBUFFER_RED_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE: if (base_format == GL_RED || base_format == GL_RG || base_format == GL_RGB || base_format == GL_RGBA) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_GREEN_SIZE: case GL_TEXTURE_GREEN_TYPE: case GL_RENDERBUFFER_GREEN_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE: if (base_format == GL_RG || base_format == GL_RGB || base_format == GL_RGBA) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_BLUE_SIZE: case GL_TEXTURE_BLUE_TYPE: case GL_RENDERBUFFER_BLUE_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE: if (base_format == GL_RGB || base_format == GL_RGBA) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_ALPHA_SIZE: case GL_TEXTURE_ALPHA_TYPE: case GL_RENDERBUFFER_ALPHA_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE: if (base_format == GL_RGBA || base_format == GL_ALPHA || base_format == GL_LUMINANCE_ALPHA) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_LUMINANCE_SIZE: case GL_TEXTURE_LUMINANCE_TYPE: if (base_format == GL_LUMINANCE || base_format == GL_LUMINANCE_ALPHA) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_INTENSITY_SIZE: case GL_TEXTURE_INTENSITY_TYPE: if (base_format == GL_INTENSITY) { return GL_TRUE; } return GL_FALSE; case GL_TEXTURE_DEPTH_SIZE: case GL_TEXTURE_DEPTH_TYPE: case GL_RENDERBUFFER_DEPTH_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE: if (base_format == GL_DEPTH_STENCIL || base_format == GL_DEPTH_COMPONENT) { return GL_TRUE; } return GL_FALSE; case GL_RENDERBUFFER_STENCIL_SIZE_EXT: case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE: if (base_format == GL_DEPTH_STENCIL || base_format == GL_STENCIL_INDEX) { return GL_TRUE; } return GL_FALSE; default: _mesa_warning(NULL, "%s: Unexpected channel token 0x%x\n", __func__, pname); return GL_FALSE; } return GL_FALSE; } /** * Returns the number of channels/components for a base format. */ GLint _mesa_base_format_component_count(GLenum base_format) { switch (base_format) { case GL_RED: case GL_ALPHA: case GL_INTENSITY: case GL_DEPTH_COMPONENT: return 1; case GL_RG: case GL_LUMINANCE_ALPHA: case GL_DEPTH_STENCIL: return 2; case GL_RGB: return 3; case GL_RGBA: return 4; default: return -1; } } /** * If format is a generic compressed format, return the corresponding * non-compressed format. For other formats, return the format as-is. */ GLenum _mesa_generic_compressed_format_to_uncompressed_format(GLenum format) { switch (format) { case GL_COMPRESSED_RED: return GL_RED; case GL_COMPRESSED_RG: return GL_RG; case GL_COMPRESSED_RGB: return GL_RGB; case GL_COMPRESSED_RGBA: return GL_RGBA; case GL_COMPRESSED_ALPHA: return GL_ALPHA; case GL_COMPRESSED_LUMINANCE: return GL_LUMINANCE; case GL_COMPRESSED_LUMINANCE_ALPHA: return GL_LUMINANCE_ALPHA; case GL_COMPRESSED_INTENSITY: return GL_INTENSITY; /* sRGB formats */ case GL_COMPRESSED_SRGB: return GL_SRGB; case GL_COMPRESSED_SRGB_ALPHA: return GL_SRGB_ALPHA; case GL_COMPRESSED_SLUMINANCE: return GL_SLUMINANCE; case GL_COMPRESSED_SLUMINANCE_ALPHA: return GL_SLUMINANCE_ALPHA; default: return format; } } /** * Return the equivalent non-generic internal format. * This is useful for comparing whether two internal formats are equivalent. */ GLenum _mesa_get_nongeneric_internalformat(GLenum format) { switch (format) { /* GL 1.1 formats. */ case 4: case GL_RGBA: return GL_RGBA8; case 3: case GL_RGB: return GL_RGB8; case 2: case GL_LUMINANCE_ALPHA: return GL_LUMINANCE8_ALPHA8; case 1: case GL_LUMINANCE: return GL_LUMINANCE8; case GL_ALPHA: return GL_ALPHA8; case GL_INTENSITY: return GL_INTENSITY8; /* GL_ARB_texture_rg */ case GL_RED: return GL_R8; case GL_RG: return GL_RG8; /* GL_EXT_texture_sRGB */ case GL_SRGB: return GL_SRGB8; case GL_SRGB_ALPHA: return GL_SRGB8_ALPHA8; case GL_SLUMINANCE: return GL_SLUMINANCE8; case GL_SLUMINANCE_ALPHA: return GL_SLUMINANCE8_ALPHA8; /* GL_EXT_texture_snorm */ case GL_RGBA_SNORM: return GL_RGBA8_SNORM; case GL_RGB_SNORM: return GL_RGB8_SNORM; case GL_RG_SNORM: return GL_RG8_SNORM; case GL_RED_SNORM: return GL_R8_SNORM; case GL_LUMINANCE_ALPHA_SNORM: return GL_LUMINANCE8_ALPHA8_SNORM; case GL_LUMINANCE_SNORM: return GL_LUMINANCE8_SNORM; case GL_ALPHA_SNORM: return GL_ALPHA8_SNORM; case GL_INTENSITY_SNORM: return GL_INTENSITY8_SNORM; default: return format; } } /** * Convert an sRGB internal format to linear. */ GLenum _mesa_get_linear_internalformat(GLenum format) { switch (format) { case GL_SRGB: return GL_RGB; case GL_SRGB_ALPHA: return GL_RGBA; case GL_SRGB8: return GL_RGB8; case GL_SRGB8_ALPHA8: return GL_RGBA8; case GL_SLUMINANCE8: return GL_LUMINANCE8; case GL_SLUMINANCE: return GL_LUMINANCE; case GL_SLUMINANCE_ALPHA: return GL_LUMINANCE_ALPHA; case GL_SLUMINANCE8_ALPHA8: return GL_LUMINANCE8_ALPHA8; default: return format; } } /** * Do error checking of format/type combinations for glReadPixels, * glDrawPixels and glTex[Sub]Image. Note that depending on the format * and type values, we may either generate GL_INVALID_OPERATION or * GL_INVALID_ENUM. * * \param format pixel format. * \param type pixel type. * * \return GL_INVALID_ENUM, GL_INVALID_OPERATION or GL_NO_ERROR */ GLenum _mesa_error_check_format_and_type(const struct gl_context *ctx, GLenum format, GLenum type) { /* From OpenGL 3.3 spec, page 220: * "If the format is DEPTH_STENCIL, then values are taken from * both the depth buffer and the stencil buffer. If there is no * depth buffer or if there is no stencil buffer, then the error * INVALID_OPERATION occurs. If the type parameter is not * UNSIGNED_INT_24_8 or FLOAT_32_UNSIGNED_INT_24_8_REV, then the * error INVALID_ENUM occurs." * * OpenGL ES still generates GL_INVALID_OPERATION because glReadPixels * cannot be used to read depth or stencil in that API. */ if (_mesa_is_desktop_gl(ctx) && format == GL_DEPTH_STENCIL && type != GL_UNSIGNED_INT_24_8 && type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV) return GL_INVALID_ENUM; /* special type-based checks (see glReadPixels, glDrawPixels error lists) */ switch (type) { case GL_BITMAP: if (format != GL_COLOR_INDEX && format != GL_STENCIL_INDEX) { return GL_INVALID_ENUM; } break; case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: if (format == GL_RGB) { break; /* OK */ } if (format == GL_RGB_INTEGER_EXT && ctx->Extensions.ARB_texture_rgb10_a2ui) { break; /* OK */ } return GL_INVALID_OPERATION; case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT) { break; /* OK */ } if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && ctx->Extensions.ARB_texture_rgb10_a2ui) { break; /* OK */ } return GL_INVALID_OPERATION; case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: if (format == GL_RGBA || format == GL_BGRA) { break; /* OK */ } if ((format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) && ctx->Extensions.ARB_texture_rgb10_a2ui) { break; /* OK */ } if (type == GL_UNSIGNED_INT_2_10_10_10_REV && format == GL_RGB && ctx->API == API_OPENGLES2) { break; /* OK by GL_EXT_texture_type_2_10_10_10_REV */ } return GL_INVALID_OPERATION; case GL_UNSIGNED_INT_24_8: /* Depth buffer OK to read in OpenGL ES (NV_read_depth). */ if (ctx->API == API_OPENGLES2 && format == GL_DEPTH_COMPONENT) return GL_NO_ERROR; if (format != GL_DEPTH_STENCIL) { return GL_INVALID_OPERATION; } return GL_NO_ERROR; case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: if (!ctx->Extensions.ARB_depth_buffer_float) { return GL_INVALID_ENUM; } if (format != GL_DEPTH_STENCIL) { return GL_INVALID_OPERATION; } return GL_NO_ERROR; case GL_UNSIGNED_INT_10F_11F_11F_REV: if (!ctx->Extensions.EXT_packed_float) { return GL_INVALID_ENUM; } if (format != GL_RGB) { return GL_INVALID_OPERATION; } return GL_NO_ERROR; case GL_HALF_FLOAT_OES: switch (format) { case GL_RGBA: case GL_RGB: case GL_LUMINANCE_ALPHA: case GL_LUMINANCE: case GL_ALPHA: return GL_NO_ERROR; case GL_RG: case GL_RED: if (_mesa_is_gles3(ctx) || ctx->Extensions.ARB_texture_rg) return GL_NO_ERROR; default: return GL_INVALID_OPERATION; } default: ; /* fall-through */ } /* now, for each format, check the type for compatibility */ switch (format) { case GL_COLOR_INDEX: case GL_STENCIL_INDEX: switch (type) { case GL_BITMAP: case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_RED: case GL_GREEN: case GL_BLUE: case GL_ALPHA: #if 0 /* not legal! see table 3.6 of the 1.5 spec */ case GL_INTENSITY: #endif case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_DEPTH_COMPONENT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_RG: if (!ctx->Extensions.ARB_texture_rg) return GL_INVALID_ENUM; switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_RGB: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: case GL_HALF_FLOAT: return GL_NO_ERROR; case GL_UNSIGNED_INT_2_10_10_10_REV: /* OK by GL_EXT_texture_type_2_10_10_10_REV */ return (ctx->API == API_OPENGLES2) ? GL_NO_ERROR : GL_INVALID_ENUM; case GL_UNSIGNED_INT_5_9_9_9_REV: return ctx->Extensions.EXT_texture_shared_exponent ? GL_NO_ERROR : GL_INVALID_ENUM; case GL_UNSIGNED_INT_10F_11F_11F_REV: return ctx->Extensions.EXT_packed_float ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } case GL_BGR: switch (type) { /* NOTE: no packed types are supported with BGR. That's * intentional, according to the GL spec. */ case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_RGBA: case GL_BGRA: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_ABGR_EXT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: case GL_FLOAT: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_HALF_FLOAT: return GL_NO_ERROR; default: return GL_INVALID_ENUM; } case GL_YCBCR_MESA: if (!ctx->Extensions.MESA_ycbcr_texture) return GL_INVALID_ENUM; if (type == GL_UNSIGNED_SHORT_8_8_MESA || type == GL_UNSIGNED_SHORT_8_8_REV_MESA) return GL_NO_ERROR; else return GL_INVALID_OPERATION; case GL_DEPTH_STENCIL: if (type == GL_UNSIGNED_INT_24_8) return GL_NO_ERROR; else if (ctx->Extensions.ARB_depth_buffer_float && type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) return GL_NO_ERROR; else return GL_INVALID_ENUM; /* integer-valued formats */ case GL_RED_INTEGER_EXT: case GL_GREEN_INTEGER_EXT: case GL_BLUE_INTEGER_EXT: case GL_ALPHA_INTEGER_EXT: case GL_RG_INTEGER: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: return (ctx->Version >= 30 || ctx->Extensions.EXT_texture_integer) ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } case GL_RGB_INTEGER_EXT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: return (ctx->Version >= 30 || ctx->Extensions.EXT_texture_integer) ? GL_NO_ERROR : GL_INVALID_ENUM; case GL_UNSIGNED_BYTE_3_3_2: case GL_UNSIGNED_BYTE_2_3_3_REV: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_5_6_5_REV: return ctx->Extensions.ARB_texture_rgb10_a2ui ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } case GL_BGR_INTEGER_EXT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: /* NOTE: no packed formats w/ BGR format */ return (ctx->Version >= 30 || ctx->Extensions.EXT_texture_integer) ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } case GL_RGBA_INTEGER_EXT: case GL_BGRA_INTEGER_EXT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: return (ctx->Version >= 30 || ctx->Extensions.EXT_texture_integer) ? GL_NO_ERROR : GL_INVALID_ENUM; case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_4_4_4_4_REV: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT_1_5_5_5_REV: case GL_UNSIGNED_INT_8_8_8_8: case GL_UNSIGNED_INT_8_8_8_8_REV: case GL_UNSIGNED_INT_10_10_10_2: case GL_UNSIGNED_INT_2_10_10_10_REV: return ctx->Extensions.ARB_texture_rgb10_a2ui ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } case GL_LUMINANCE_INTEGER_EXT: case GL_LUMINANCE_ALPHA_INTEGER_EXT: switch (type) { case GL_BYTE: case GL_UNSIGNED_BYTE: case GL_SHORT: case GL_UNSIGNED_SHORT: case GL_INT: case GL_UNSIGNED_INT: return ctx->Extensions.EXT_texture_integer ? GL_NO_ERROR : GL_INVALID_ENUM; default: return GL_INVALID_ENUM; } default: return GL_INVALID_ENUM; } return GL_NO_ERROR; } /** * Do error checking of format/type combinations for OpenGL ES glReadPixels * and glTex[Sub]Image. * \return error code, or GL_NO_ERROR. */ GLenum _mesa_es_error_check_format_and_type(const struct gl_context *ctx, GLenum format, GLenum type, unsigned dimensions) { GLboolean type_valid = GL_TRUE; switch (format) { case GL_RED: case GL_RG: if (ctx->API == API_OPENGLES || !ctx->Extensions.ARB_texture_rg) return GL_INVALID_VALUE; /* fallthrough */ case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: type_valid = (type == GL_UNSIGNED_BYTE || type == GL_FLOAT || type == GL_HALF_FLOAT_OES); break; case GL_RGB: type_valid = (type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_SHORT_5_6_5 || type == GL_FLOAT || type == GL_HALF_FLOAT_OES); break; case GL_RGBA: type_valid = (type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_SHORT_4_4_4_4 || type == GL_UNSIGNED_SHORT_5_5_5_1 || type == GL_FLOAT || type == GL_HALF_FLOAT_OES || type == GL_UNSIGNED_INT_2_10_10_10_REV); break; case GL_DEPTH_COMPONENT: /* This format is filtered against invalid dimensionalities elsewhere. */ type_valid = (type == GL_UNSIGNED_SHORT || type == GL_UNSIGNED_INT); break; case GL_DEPTH_STENCIL: /* This format is filtered against invalid dimensionalities elsewhere. */ type_valid = (type == GL_UNSIGNED_INT_24_8); break; case GL_BGRA_EXT: type_valid = (type == GL_UNSIGNED_BYTE); /* This feels like a bug in the EXT_texture_format_BGRA8888 spec, but * the format does not appear to be allowed for 3D textures in OpenGL * ES. */ if (dimensions != 2) return GL_INVALID_VALUE; break; default: return GL_INVALID_VALUE; } return type_valid ? GL_NO_ERROR : GL_INVALID_OPERATION; } /** * Return the simple base format for a given internal texture format. * For example, given GL_LUMINANCE12_ALPHA4, return GL_LUMINANCE_ALPHA. * * \param ctx GL context. * \param internalFormat the internal texture format token or 1, 2, 3, or 4. * * \return the corresponding \u base internal format (GL_ALPHA, GL_LUMINANCE, * GL_LUMANCE_ALPHA, GL_INTENSITY, GL_RGB, or GL_RGBA), or -1 if invalid enum. * * This is the format which is used during texture application (i.e. the * texture format and env mode determine the arithmetic used. */ GLint _mesa_base_tex_format(const struct gl_context *ctx, GLint internalFormat) { switch (internalFormat) { case GL_ALPHA: case GL_ALPHA4: case GL_ALPHA8: case GL_ALPHA12: case GL_ALPHA16: return (ctx->API != API_OPENGL_CORE) ? GL_ALPHA : -1; case 1: case GL_LUMINANCE: case GL_LUMINANCE4: case GL_LUMINANCE8: case GL_LUMINANCE12: case GL_LUMINANCE16: return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE : -1; case 2: case GL_LUMINANCE_ALPHA: case GL_LUMINANCE4_ALPHA4: case GL_LUMINANCE6_ALPHA2: case GL_LUMINANCE8_ALPHA8: case GL_LUMINANCE12_ALPHA4: case GL_LUMINANCE12_ALPHA12: case GL_LUMINANCE16_ALPHA16: return (ctx->API != API_OPENGL_CORE) ? GL_LUMINANCE_ALPHA : -1; case GL_INTENSITY: case GL_INTENSITY4: case GL_INTENSITY8: case GL_INTENSITY12: case GL_INTENSITY16: return (ctx->API != API_OPENGL_CORE) ? GL_INTENSITY : -1; case 3: return (ctx->API != API_OPENGL_CORE) ? GL_RGB : -1; case GL_RGB: case GL_R3_G3_B2: case GL_RGB4: case GL_RGB5: case GL_RGB8: case GL_RGB10: case GL_RGB12: case GL_RGB16: return GL_RGB; case 4: return (ctx->API != API_OPENGL_CORE) ? GL_RGBA : -1; case GL_RGBA: case GL_RGBA2: case GL_RGBA4: case GL_RGB5_A1: case GL_RGBA8: case GL_RGB10_A2: case GL_RGBA12: case GL_RGBA16: return GL_RGBA; default: ; /* fallthrough */ } /* GL_BGRA can be an internal format *only* in OpenGL ES (1.x or 2.0). */ if (_mesa_is_gles(ctx)) { switch (internalFormat) { case GL_BGRA: return GL_RGBA; default: ; /* fallthrough */ } } if (ctx->Extensions.ARB_ES2_compatibility) { switch (internalFormat) { case GL_RGB565: return GL_RGB; default: ; /* fallthrough */ } } if (ctx->Extensions.ARB_depth_texture) { switch (internalFormat) { case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT24: case GL_DEPTH_COMPONENT32: return GL_DEPTH_COMPONENT; case GL_DEPTH_STENCIL: case GL_DEPTH24_STENCIL8: return GL_DEPTH_STENCIL; default: ; /* fallthrough */ } } if (ctx->Extensions.ARB_texture_stencil8) { switch (internalFormat) { case GL_STENCIL_INDEX: case GL_STENCIL_INDEX1: case GL_STENCIL_INDEX4: case GL_STENCIL_INDEX8: case GL_STENCIL_INDEX16: return GL_STENCIL_INDEX; default: ; /* fallthrough */ } } switch (internalFormat) { case GL_COMPRESSED_ALPHA: return GL_ALPHA; case GL_COMPRESSED_LUMINANCE: return GL_LUMINANCE; case GL_COMPRESSED_LUMINANCE_ALPHA: return GL_LUMINANCE_ALPHA; case GL_COMPRESSED_INTENSITY: return GL_INTENSITY; case GL_COMPRESSED_RGB: return GL_RGB; case GL_COMPRESSED_RGBA: return GL_RGBA; default: ; /* fallthrough */ } if (_mesa_is_compressed_format(ctx, internalFormat)) { GLenum base_compressed = _mesa_gl_compressed_format_base_format(internalFormat); if (base_compressed) return base_compressed; } if (ctx->Extensions.KHR_texture_compression_astc_ldr && _mesa_is_astc_format(internalFormat)) return GL_RGBA; if (ctx->Extensions.MESA_ycbcr_texture) { if (internalFormat == GL_YCBCR_MESA) return GL_YCBCR_MESA; } if (ctx->Extensions.ARB_texture_float) { switch (internalFormat) { case GL_ALPHA16F_ARB: case GL_ALPHA32F_ARB: return GL_ALPHA; case GL_RGBA16F_ARB: case GL_RGBA32F_ARB: return GL_RGBA; case GL_RGB16F_ARB: case GL_RGB32F_ARB: return GL_RGB; case GL_INTENSITY16F_ARB: case GL_INTENSITY32F_ARB: return GL_INTENSITY; case GL_LUMINANCE16F_ARB: case GL_LUMINANCE32F_ARB: return GL_LUMINANCE; case GL_LUMINANCE_ALPHA16F_ARB: case GL_LUMINANCE_ALPHA32F_ARB: return GL_LUMINANCE_ALPHA; default: ; /* fallthrough */ } } if (ctx->Extensions.EXT_texture_snorm) { switch (internalFormat) { case GL_RED_SNORM: case GL_R8_SNORM: case GL_R16_SNORM: return GL_RED; case GL_RG_SNORM: case GL_RG8_SNORM: case GL_RG16_SNORM: return GL_RG; case GL_RGB_SNORM: case GL_RGB8_SNORM: case GL_RGB16_SNORM: return GL_RGB; case GL_RGBA_SNORM: case GL_RGBA8_SNORM: case GL_RGBA16_SNORM: return GL_RGBA; case GL_ALPHA_SNORM: case GL_ALPHA8_SNORM: case GL_ALPHA16_SNORM: return GL_ALPHA; case GL_LUMINANCE_SNORM: case GL_LUMINANCE8_SNORM: case GL_LUMINANCE16_SNORM: return GL_LUMINANCE; case GL_LUMINANCE_ALPHA_SNORM: case GL_LUMINANCE8_ALPHA8_SNORM: case GL_LUMINANCE16_ALPHA16_SNORM: return GL_LUMINANCE_ALPHA; case GL_INTENSITY_SNORM: case GL_INTENSITY8_SNORM: case GL_INTENSITY16_SNORM: return GL_INTENSITY; default: ; /* fallthrough */ } } if (ctx->Extensions.EXT_texture_sRGB) { switch (internalFormat) { case GL_SRGB_EXT: case GL_SRGB8_EXT: case GL_COMPRESSED_SRGB_EXT: return GL_RGB; case GL_SRGB_ALPHA_EXT: case GL_SRGB8_ALPHA8_EXT: case GL_COMPRESSED_SRGB_ALPHA_EXT: return GL_RGBA; case GL_SLUMINANCE_ALPHA_EXT: case GL_SLUMINANCE8_ALPHA8_EXT: case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: return GL_LUMINANCE_ALPHA; case GL_SLUMINANCE_EXT: case GL_SLUMINANCE8_EXT: case GL_COMPRESSED_SLUMINANCE_EXT: return GL_LUMINANCE; default: ; /* fallthrough */ } } if (ctx->Version >= 30 || ctx->Extensions.EXT_texture_integer) { switch (internalFormat) { case GL_RGBA8UI_EXT: case GL_RGBA16UI_EXT: case GL_RGBA32UI_EXT: case GL_RGBA8I_EXT: case GL_RGBA16I_EXT: case GL_RGBA32I_EXT: case GL_RGB10_A2UI: return GL_RGBA; case GL_RGB8UI_EXT: case GL_RGB16UI_EXT: case GL_RGB32UI_EXT: case GL_RGB8I_EXT: case GL_RGB16I_EXT: case GL_RGB32I_EXT: return GL_RGB; } } if (ctx->Extensions.EXT_texture_integer) { switch (internalFormat) { case GL_ALPHA8UI_EXT: case GL_ALPHA16UI_EXT: case GL_ALPHA32UI_EXT: case GL_ALPHA8I_EXT: case GL_ALPHA16I_EXT: case GL_ALPHA32I_EXT: return GL_ALPHA; case GL_INTENSITY8UI_EXT: case GL_INTENSITY16UI_EXT: case GL_INTENSITY32UI_EXT: case GL_INTENSITY8I_EXT: case GL_INTENSITY16I_EXT: case GL_INTENSITY32I_EXT: return GL_INTENSITY; case GL_LUMINANCE8UI_EXT: case GL_LUMINANCE16UI_EXT: case GL_LUMINANCE32UI_EXT: case GL_LUMINANCE8I_EXT: case GL_LUMINANCE16I_EXT: case GL_LUMINANCE32I_EXT: return GL_LUMINANCE; case GL_LUMINANCE_ALPHA8UI_EXT: case GL_LUMINANCE_ALPHA16UI_EXT: case GL_LUMINANCE_ALPHA32UI_EXT: case GL_LUMINANCE_ALPHA8I_EXT: case GL_LUMINANCE_ALPHA16I_EXT: case GL_LUMINANCE_ALPHA32I_EXT: return GL_LUMINANCE_ALPHA; default: ; /* fallthrough */ } } if (ctx->Extensions.ARB_texture_rg) { switch (internalFormat) { case GL_R16F: case GL_R32F: if (!ctx->Extensions.ARB_texture_float) break; return GL_RED; case GL_R8I: case GL_R8UI: case GL_R16I: case GL_R16UI: case GL_R32I: case GL_R32UI: if (ctx->Version < 30 && !ctx->Extensions.EXT_texture_integer) break; /* FALLTHROUGH */ case GL_R8: case GL_R16: case GL_RED: case GL_COMPRESSED_RED: return GL_RED; case GL_RG16F: case GL_RG32F: if (!ctx->Extensions.ARB_texture_float) break; return GL_RG; case GL_RG8I: case GL_RG8UI: case GL_RG16I: case GL_RG16UI: case GL_RG32I: case GL_RG32UI: if (ctx->Version < 30 && !ctx->Extensions.EXT_texture_integer) break; /* FALLTHROUGH */ case GL_RG: case GL_RG8: case GL_RG16: case GL_COMPRESSED_RG: return GL_RG; default: ; /* fallthrough */ } } if (ctx->Extensions.EXT_texture_shared_exponent) { switch (internalFormat) { case GL_RGB9_E5_EXT: return GL_RGB; default: ; /* fallthrough */ } } if (ctx->Extensions.EXT_packed_float) { switch (internalFormat) { case GL_R11F_G11F_B10F_EXT: return GL_RGB; default: ; /* fallthrough */ } } if (ctx->Extensions.ARB_depth_buffer_float) { switch (internalFormat) { case GL_DEPTH_COMPONENT32F: return GL_DEPTH_COMPONENT; case GL_DEPTH32F_STENCIL8: return GL_DEPTH_STENCIL; default: ; /* fallthrough */ } } return -1; /* error */ } /** * Returns the effective internal format from a texture format and type. * This is used by texture image operations internally for validation, when * the specified internal format is a base (unsized) format. * * This method will only return a valid effective internal format if the * combination of format, type and internal format in base form, is acceptable. * * If a single sized internal format is defined in the spec (OpenGL-ES 3.0.4) or * in extensions, to unambiguously correspond to the given base format, then * that internal format is returned as the effective. Otherwise, if the * combination is accepted but a single effective format is not defined, the * passed base format will be returned instead. * * \param format the texture format * \param type the texture type */ static GLenum _mesa_es3_effective_internal_format_for_format_and_type(GLenum format, GLenum type) { switch (type) { case GL_UNSIGNED_BYTE: switch (format) { case GL_RGBA: return GL_RGBA8; case GL_RGB: return GL_RGB8; /* Although LUMINANCE_ALPHA, LUMINANCE and ALPHA appear in table 3.12, * (section 3.8 Texturing, page 128 of the OpenGL-ES 3.0.4) as effective * internal formats, they do not correspond to GL constants, so the base * format is returned instead. */ case GL_BGRA_EXT: case GL_LUMINANCE_ALPHA: case GL_LUMINANCE: case GL_ALPHA: return format; } break; case GL_UNSIGNED_SHORT_4_4_4_4: if (format == GL_RGBA) return GL_RGBA4; break; case GL_UNSIGNED_SHORT_5_5_5_1: if (format == GL_RGBA) return GL_RGB5_A1; break; case GL_UNSIGNED_SHORT_5_6_5: if (format == GL_RGB) return GL_RGB565; break; /* OES_packed_depth_stencil */ case GL_UNSIGNED_INT_24_8: if (format == GL_DEPTH_STENCIL) return GL_DEPTH24_STENCIL8; break; case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: if (format == GL_DEPTH_STENCIL) return GL_DEPTH32F_STENCIL8; break; case GL_UNSIGNED_SHORT: if (format == GL_DEPTH_COMPONENT) return GL_DEPTH_COMPONENT16; break; case GL_UNSIGNED_INT: /* It can be DEPTH_COMPONENT16 or DEPTH_COMPONENT24, so just return * the format. */ if (format == GL_DEPTH_COMPONENT) return format; break; /* OES_texture_float and OES_texture_half_float */ case GL_FLOAT: if (format == GL_DEPTH_COMPONENT) return GL_DEPTH_COMPONENT32F; /* fall through */ case GL_HALF_FLOAT_OES: switch (format) { case GL_RGBA: case GL_RGB: case GL_LUMINANCE_ALPHA: case GL_LUMINANCE: case GL_ALPHA: case GL_RED: case GL_RG: return format; } break; case GL_HALF_FLOAT: switch (format) { case GL_RG: case GL_RED: return format; } break; /* GL_EXT_texture_type_2_10_10_10_REV */ case GL_UNSIGNED_INT_2_10_10_10_REV: switch (format) { case GL_RGBA: case GL_RGB: return format; } break; default: /* fall through and return NONE */ break; } return GL_NONE; } /** * Do error checking of format/type combinations for OpenGL ES 3 * glTex[Sub]Image. * \return error code, or GL_NO_ERROR. */ GLenum _mesa_es3_error_check_format_and_type(const struct gl_context *ctx, GLenum format, GLenum type, GLenum internalFormat) { /* If internalFormat is an unsized format, then the effective internal * format derived from format and type should be used instead. Page 127, * section "3.8 Texturing" of the GLES 3.0.4 spec states: * * "if internalformat is a base internal format, the effective * internal format is a sized internal format that is derived * from the format and type for internal use by the GL. * Table 3.12 specifies the mapping of format and type to effective * internal formats. The effective internal format is used by the GL * for purposes such as texture completeness or type checks for * CopyTex* commands. In these cases, the GL is required to operate * as if the effective internal format was used as the internalformat * when specifying the texture data." */ if (_mesa_is_enum_format_unsized(internalFormat)) { GLenum effectiveInternalFormat = _mesa_es3_effective_internal_format_for_format_and_type(format, type); if (effectiveInternalFormat == GL_NONE) return GL_INVALID_OPERATION; GLenum baseInternalFormat; if (internalFormat == GL_BGRA_EXT) { /* Unfortunately, _mesa_base_tex_format returns a base format of * GL_RGBA for GL_BGRA_EXT. This makes perfect sense if you're * asking the question, "what channels does this format have?" * However, if we're trying to determine if two internal formats * match in the ES3 sense, we actually want GL_BGRA. */ baseInternalFormat = GL_BGRA_EXT; } else { baseInternalFormat = _mesa_base_tex_format(ctx, effectiveInternalFormat); } if (internalFormat != baseInternalFormat) return GL_INVALID_OPERATION; internalFormat = effectiveInternalFormat; } switch (format) { case GL_BGRA_EXT: if (type != GL_UNSIGNED_BYTE || internalFormat != GL_BGRA) return GL_INVALID_OPERATION; break; case GL_RGBA: switch (type) { case GL_UNSIGNED_BYTE: switch (internalFormat) { case GL_RGBA: case GL_RGBA8: case GL_RGB5_A1: case GL_RGBA4: case GL_SRGB8_ALPHA8_EXT: break; default: return GL_INVALID_OPERATION; } break; case GL_BYTE: if (internalFormat != GL_RGBA8_SNORM) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT_4_4_4_4: switch (internalFormat) { case GL_RGBA: case GL_RGBA4: break; default: return GL_INVALID_OPERATION; } break; case GL_UNSIGNED_SHORT_5_5_5_1: switch (internalFormat) { case GL_RGBA: case GL_RGB5_A1: break; default: return GL_INVALID_OPERATION; } break; case GL_UNSIGNED_INT_2_10_10_10_REV: switch (internalFormat) { case GL_RGBA: /* GL_EXT_texture_type_2_10_10_10_REV */ case GL_RGB10_A2: case GL_RGB5_A1: break; default: return GL_INVALID_OPERATION; } break; case GL_HALF_FLOAT: if (internalFormat != GL_RGBA16F) return GL_INVALID_OPERATION; break; case GL_FLOAT: switch (internalFormat) { case GL_RGBA16F: case GL_RGBA32F: break; case GL_RGBA: if (ctx->Extensions.OES_texture_float && internalFormat == format) break; default: return GL_INVALID_OPERATION; } break; case GL_HALF_FLOAT_OES: if (ctx->Extensions.OES_texture_half_float && internalFormat == format) break; default: return GL_INVALID_OPERATION; } break; case GL_RGBA_INTEGER: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_RGBA8UI) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_RGBA8I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT: if (internalFormat != GL_RGBA16UI) return GL_INVALID_OPERATION; break; case GL_SHORT: if (internalFormat != GL_RGBA16I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT: if (internalFormat != GL_RGBA32UI) return GL_INVALID_OPERATION; break; case GL_INT: if (internalFormat != GL_RGBA32I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT_2_10_10_10_REV: if (internalFormat != GL_RGB10_A2UI) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_RGB: switch (type) { case GL_UNSIGNED_BYTE: switch (internalFormat) { case GL_RGB: case GL_RGB8: case GL_RGB565: case GL_SRGB8: break; default: return GL_INVALID_OPERATION; } break; case GL_BYTE: if (internalFormat != GL_RGB8_SNORM) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT_5_6_5: switch (internalFormat) { case GL_RGB: case GL_RGB565: break; default: return GL_INVALID_OPERATION; } break; case GL_UNSIGNED_INT_10F_11F_11F_REV: if (internalFormat != GL_R11F_G11F_B10F) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT_5_9_9_9_REV: if (internalFormat != GL_RGB9_E5) return GL_INVALID_OPERATION; break; case GL_HALF_FLOAT: switch (internalFormat) { case GL_RGB16F: case GL_R11F_G11F_B10F: case GL_RGB9_E5: break; default: return GL_INVALID_OPERATION; } break; case GL_FLOAT: switch (internalFormat) { case GL_RGB16F: case GL_RGB32F: case GL_R11F_G11F_B10F: case GL_RGB9_E5: break; case GL_RGB: if (ctx->Extensions.OES_texture_float && internalFormat == format) break; default: return GL_INVALID_OPERATION; } break; case GL_HALF_FLOAT_OES: if (!ctx->Extensions.OES_texture_half_float || internalFormat != format) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT_2_10_10_10_REV: switch (internalFormat) { case GL_RGB: /* GL_EXT_texture_type_2_10_10_10_REV */ break; default: return GL_INVALID_OPERATION; } break; default: return GL_INVALID_OPERATION; } break; case GL_RGB_INTEGER: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_RGB8UI) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_RGB8I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT: if (internalFormat != GL_RGB16UI) return GL_INVALID_OPERATION; break; case GL_SHORT: if (internalFormat != GL_RGB16I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT: if (internalFormat != GL_RGB32UI) return GL_INVALID_OPERATION; break; case GL_INT: if (internalFormat != GL_RGB32I) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_RG: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_RG8) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_RG8_SNORM) return GL_INVALID_OPERATION; break; case GL_HALF_FLOAT: case GL_HALF_FLOAT_OES: switch (internalFormat) { case GL_RG16F: break; case GL_RG: if (ctx->Extensions.ARB_texture_rg && ctx->Extensions.OES_texture_half_float) break; /* fallthrough */ default: return GL_INVALID_OPERATION; } break; case GL_FLOAT: switch (internalFormat) { case GL_RG16F: case GL_RG32F: break; case GL_RG: if (ctx->Extensions.ARB_texture_rg && ctx->Extensions.OES_texture_float) break; /* fallthrough */ default: return GL_INVALID_OPERATION; } break; default: return GL_INVALID_OPERATION; } break; case GL_RG_INTEGER: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_RG8UI) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_RG8I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT: if (internalFormat != GL_RG16UI) return GL_INVALID_OPERATION; break; case GL_SHORT: if (internalFormat != GL_RG16I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT: if (internalFormat != GL_RG32UI) return GL_INVALID_OPERATION; break; case GL_INT: if (internalFormat != GL_RG32I) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_RED: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_R8) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_R8_SNORM) return GL_INVALID_OPERATION; break; case GL_HALF_FLOAT: case GL_HALF_FLOAT_OES: switch (internalFormat) { case GL_R16F: break; case GL_RG: case GL_RED: if (ctx->Extensions.ARB_texture_rg && ctx->Extensions.OES_texture_half_float) break; /* fallthrough */ default: return GL_INVALID_OPERATION; } break; case GL_FLOAT: switch (internalFormat) { case GL_R16F: case GL_R32F: break; case GL_RED: if (ctx->Extensions.ARB_texture_rg && ctx->Extensions.OES_texture_float) break; /* fallthrough */ default: return GL_INVALID_OPERATION; } break; default: return GL_INVALID_OPERATION; } break; case GL_RED_INTEGER: switch (type) { case GL_UNSIGNED_BYTE: if (internalFormat != GL_R8UI) return GL_INVALID_OPERATION; break; case GL_BYTE: if (internalFormat != GL_R8I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_SHORT: if (internalFormat != GL_R16UI) return GL_INVALID_OPERATION; break; case GL_SHORT: if (internalFormat != GL_R16I) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT: if (internalFormat != GL_R32UI) return GL_INVALID_OPERATION; break; case GL_INT: if (internalFormat != GL_R32I) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_DEPTH_COMPONENT: switch (type) { case GL_UNSIGNED_SHORT: if (internalFormat != GL_DEPTH_COMPONENT && internalFormat != GL_DEPTH_COMPONENT16) return GL_INVALID_OPERATION; break; case GL_UNSIGNED_INT: switch (internalFormat) { case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT24: break; default: return GL_INVALID_OPERATION; } break; case GL_FLOAT: if (internalFormat != GL_DEPTH_COMPONENT32F) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_DEPTH_STENCIL: switch (type) { case GL_UNSIGNED_INT_24_8: if (internalFormat != GL_DEPTH_STENCIL && internalFormat != GL_DEPTH24_STENCIL8) return GL_INVALID_OPERATION; break; case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: if (internalFormat != GL_DEPTH32F_STENCIL8) return GL_INVALID_OPERATION; break; default: return GL_INVALID_OPERATION; } break; case GL_STENCIL_INDEX: if (!_mesa_has_OES_texture_stencil8(ctx) || type != GL_UNSIGNED_BYTE || internalFormat != GL_STENCIL_INDEX8) { return GL_INVALID_OPERATION; } break; case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: switch (type) { case GL_FLOAT: if (ctx->Extensions.OES_texture_float && internalFormat == format) break; case GL_HALF_FLOAT_OES: if (ctx->Extensions.OES_texture_half_float && internalFormat == format) break; default: if (type != GL_UNSIGNED_BYTE || format != internalFormat) return GL_INVALID_OPERATION; } } return GL_NO_ERROR; } static void set_swizzle(uint8_t *swizzle, int x, int y, int z, int w) { swizzle[MESA_FORMAT_SWIZZLE_X] = x; swizzle[MESA_FORMAT_SWIZZLE_Y] = y; swizzle[MESA_FORMAT_SWIZZLE_Z] = z; swizzle[MESA_FORMAT_SWIZZLE_W] = w; } static bool get_swizzle_from_gl_format(GLenum format, uint8_t *swizzle) { switch (format) { case GL_RGBA: case GL_RGBA_INTEGER_EXT: set_swizzle(swizzle, 0, 1, 2, 3); return true; case GL_BGRA: case GL_BGRA_INTEGER_EXT: set_swizzle(swizzle, 2, 1, 0, 3); return true; case GL_ABGR_EXT: set_swizzle(swizzle, 3, 2, 1, 0); return true; case GL_RGB: case GL_RGB_INTEGER_EXT: set_swizzle(swizzle, 0, 1, 2, 5); return true; case GL_BGR: case GL_BGR_INTEGER_EXT: set_swizzle(swizzle, 2, 1, 0, 5); return true; case GL_LUMINANCE_ALPHA: case GL_LUMINANCE_ALPHA_INTEGER_EXT: set_swizzle(swizzle, 0, 0, 0, 1); return true; case GL_RG: case GL_RG_INTEGER: set_swizzle(swizzle, 0, 1, 4, 5); return true; case GL_RED: case GL_RED_INTEGER_EXT: set_swizzle(swizzle, 0, 4, 4, 5); return true; case GL_GREEN: case GL_GREEN_INTEGER_EXT: set_swizzle(swizzle, 4, 0, 4, 5); return true; case GL_BLUE: case GL_BLUE_INTEGER_EXT: set_swizzle(swizzle, 4, 4, 0, 5); return true; case GL_ALPHA: case GL_ALPHA_INTEGER_EXT: set_swizzle(swizzle, 4, 4, 4, 0); return true; case GL_LUMINANCE: case GL_LUMINANCE_INTEGER_EXT: set_swizzle(swizzle, 0, 0, 0, 5); return true; case GL_INTENSITY: set_swizzle(swizzle, 0, 0, 0, 0); return true; default: return false; } } /** * Take an OpenGL format (GL_RGB, GL_RGBA, etc), OpenGL data type (GL_INT, * GL_FOAT, etc) and return a matching mesa_array_format or a mesa_format * otherwise (for non-array formats). * * This function will typically be used to compute a mesa format from a GL type * so we can then call _mesa_format_convert. This function does * not consider byte swapping, so it returns types assuming that no byte * swapping is involved. If byte swapping is involved then clients are supposed * to handle that on their side before calling _mesa_format_convert. * * This function returns an uint32_t that can pack a mesa_format or a * mesa_array_format. Clients must check the mesa array format bit * (MESA_ARRAY_FORMAT_BIT) on the return value to know if the returned * format is a mesa_array_format or a mesa_format. */ uint32_t _mesa_format_from_format_and_type(GLenum format, GLenum type) { bool is_array_format = true; uint8_t swizzle[4]; bool normalized = false, is_float = false, is_signed = false; int num_channels = 0, type_size = 0; /* Extract array format type information from the OpenGL data type */ switch (type) { case GL_UNSIGNED_BYTE: type_size = 1; break; case GL_BYTE: type_size = 1; is_signed = true; break; case GL_UNSIGNED_SHORT: type_size = 2; break; case GL_SHORT: type_size = 2; is_signed = true; break; case GL_UNSIGNED_INT: type_size = 4; break; case GL_INT: type_size = 4; is_signed = true; break; case GL_HALF_FLOAT: case GL_HALF_FLOAT_OES: type_size = 2; is_signed = true; is_float = true; break; case GL_FLOAT: type_size = 4; is_signed = true; is_float = true; break; default: is_array_format = false; break; } /* Extract array format swizzle information from the OpenGL format */ if (is_array_format) is_array_format = get_swizzle_from_gl_format(format, swizzle); /* If this is an array format type after checking data type and format, * create the array format */ if (is_array_format) { normalized = !_mesa_is_enum_format_integer(format); num_channels = _mesa_components_in_format(format); return MESA_ARRAY_FORMAT(type_size, is_signed, is_float, normalized, num_channels, swizzle[0], swizzle[1], swizzle[2], swizzle[3]); } /* Otherwise this is not an array format, so return the mesa_format * matching the OpenGL format and data type */ switch (type) { case GL_UNSIGNED_SHORT_5_6_5: if (format == GL_RGB) return MESA_FORMAT_B5G6R5_UNORM; else if (format == GL_BGR) return MESA_FORMAT_R5G6B5_UNORM; else if (format == GL_RGB_INTEGER) return MESA_FORMAT_B5G6R5_UINT; break; case GL_UNSIGNED_SHORT_5_6_5_REV: if (format == GL_RGB) return MESA_FORMAT_R5G6B5_UNORM; else if (format == GL_BGR) return MESA_FORMAT_B5G6R5_UNORM; else if (format == GL_RGB_INTEGER) return MESA_FORMAT_R5G6B5_UINT; break; case GL_UNSIGNED_SHORT_4_4_4_4: if (format == GL_RGBA) return MESA_FORMAT_A4B4G4R4_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_A4R4G4B4_UNORM; else if (format == GL_ABGR_EXT) return MESA_FORMAT_R4G4B4A4_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_A4B4G4R4_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_A4R4G4B4_UINT; break; case GL_UNSIGNED_SHORT_4_4_4_4_REV: if (format == GL_RGBA) return MESA_FORMAT_R4G4B4A4_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_B4G4R4A4_UNORM; else if (format == GL_ABGR_EXT) return MESA_FORMAT_A4B4G4R4_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_R4G4B4A4_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_B4G4R4A4_UINT; break; case GL_UNSIGNED_SHORT_5_5_5_1: if (format == GL_RGBA) return MESA_FORMAT_A1B5G5R5_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_A1R5G5B5_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_A1B5G5R5_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_A1R5G5B5_UINT; break; case GL_UNSIGNED_SHORT_1_5_5_5_REV: if (format == GL_RGBA) return MESA_FORMAT_R5G5B5A1_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_B5G5R5A1_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_R5G5B5A1_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_B5G5R5A1_UINT; break; case GL_UNSIGNED_BYTE_3_3_2: if (format == GL_RGB) return MESA_FORMAT_B2G3R3_UNORM; else if (format == GL_RGB_INTEGER) return MESA_FORMAT_B2G3R3_UINT; break; case GL_UNSIGNED_BYTE_2_3_3_REV: if (format == GL_RGB) return MESA_FORMAT_R3G3B2_UNORM; else if (format == GL_RGB_INTEGER) return MESA_FORMAT_R3G3B2_UINT; break; case GL_UNSIGNED_INT_5_9_9_9_REV: if (format == GL_RGB) return MESA_FORMAT_R9G9B9E5_FLOAT; break; case GL_UNSIGNED_INT_10_10_10_2: if (format == GL_RGBA) return MESA_FORMAT_A2B10G10R10_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_A2B10G10R10_UINT; else if (format == GL_BGRA) return MESA_FORMAT_A2R10G10B10_UNORM; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_A2R10G10B10_UINT; break; case GL_UNSIGNED_INT_2_10_10_10_REV: if (format == GL_RGB) return MESA_FORMAT_R10G10B10X2_UNORM; if (format == GL_RGBA) return MESA_FORMAT_R10G10B10A2_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_R10G10B10A2_UINT; else if (format == GL_BGRA) return MESA_FORMAT_B10G10R10A2_UNORM; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_B10G10R10A2_UINT; break; case GL_UNSIGNED_INT_8_8_8_8: if (format == GL_RGBA) return MESA_FORMAT_A8B8G8R8_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_A8R8G8B8_UNORM; else if (format == GL_ABGR_EXT) return MESA_FORMAT_R8G8B8A8_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_A8B8G8R8_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_A8R8G8B8_UINT; break; case GL_UNSIGNED_INT_8_8_8_8_REV: if (format == GL_RGBA) return MESA_FORMAT_R8G8B8A8_UNORM; else if (format == GL_BGRA) return MESA_FORMAT_B8G8R8A8_UNORM; else if (format == GL_ABGR_EXT) return MESA_FORMAT_A8B8G8R8_UNORM; else if (format == GL_RGBA_INTEGER) return MESA_FORMAT_R8G8B8A8_UINT; else if (format == GL_BGRA_INTEGER) return MESA_FORMAT_B8G8R8A8_UINT; break; case GL_UNSIGNED_SHORT_8_8_MESA: if (format == GL_YCBCR_MESA) return MESA_FORMAT_YCBCR; break; case GL_UNSIGNED_SHORT_8_8_REV_MESA: if (format == GL_YCBCR_MESA) return MESA_FORMAT_YCBCR_REV; break; case GL_UNSIGNED_INT_10F_11F_11F_REV: if (format == GL_RGB) return MESA_FORMAT_R11G11B10_FLOAT; default: break; } /* If we got here it means that we could not find a Mesa format that * matches the GL format/type provided. We may need to add a new Mesa * format in that case. */ unreachable("Unsupported format"); }