X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmesa%2Fstate_tracker%2Fst_format.c;h=bd4f0860c5270471abcc98fb86bb5b07d87139dc;hb=9cd64ec35acd54cbe0be4d03236d2c5a9d4be6fe;hp=22a1450cfe7e39f9ca489a099da26e755525c58e;hpb=c37e283423a33ce870e865e9adeca7f4eddf4b5b;p=mesa.git diff --git a/src/mesa/state_tracker/st_format.c b/src/mesa/state_tracker/st_format.c index 22a1450cfe7..bd4f0860c52 100644 --- a/src/mesa/state_tracker/st_format.c +++ b/src/mesa/state_tracker/st_format.c @@ -68,42 +68,70 @@ GLenum st_format_datatype(enum pipe_format format) { const struct util_format_description *desc; + int i; desc = util_format_description(format); assert(desc); + /* Find the first non-VOID channel. */ + for (i = 0; i < 4; i++) { + if (desc->channel[i].type != UTIL_FORMAT_TYPE_VOID) { + break; + } + } + if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) { if (format == PIPE_FORMAT_B5G5R5A1_UNORM || format == PIPE_FORMAT_B5G6R5_UNORM) { return GL_UNSIGNED_SHORT; } + else if (format == PIPE_FORMAT_R11G11B10_FLOAT || + format == PIPE_FORMAT_R9G9B9E5_FLOAT) { + return GL_FLOAT; + } else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED || format == PIPE_FORMAT_S8_USCALED_Z24_UNORM || format == PIPE_FORMAT_Z24X8_UNORM || format == PIPE_FORMAT_X8Z24_UNORM) { return GL_UNSIGNED_INT_24_8; } + else if (format == PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED) { + return GL_FLOAT_32_UNSIGNED_INT_24_8_REV; + } else { const GLuint size = format_max_bits(format); + + assert(i < 4); + if (i == 4) + return GL_NONE; + if (size == 8) { - if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED) + if (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED) return GL_UNSIGNED_BYTE; else return GL_BYTE; } else if (size == 16) { - if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED) + if (desc->channel[i].type == UTIL_FORMAT_TYPE_FLOAT) + return GL_HALF_FLOAT; + if (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED) return GL_UNSIGNED_SHORT; else return GL_SHORT; } - else { - assert( size <= 32 ); - if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED) + else if (size <= 32) { + if (desc->channel[i].type == UTIL_FORMAT_TYPE_FLOAT) + return GL_FLOAT; + if (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED) return GL_UNSIGNED_INT; else return GL_INT; } + else { + assert(size == 64); + assert(desc->channel[i].type == UTIL_FORMAT_TYPE_FLOAT); + return GL_DOUBLE; + } } } else if (format == PIPE_FORMAT_UYVY) { @@ -180,6 +208,10 @@ st_mesa_format_to_pipe_format(gl_format mesaFormat) return PIPE_FORMAT_Z24X8_UNORM; case MESA_FORMAT_S8: return PIPE_FORMAT_S8_USCALED; + case MESA_FORMAT_Z32_FLOAT: + return PIPE_FORMAT_Z32_FLOAT; + case MESA_FORMAT_Z32_FLOAT_X24S8: + return PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED; case MESA_FORMAT_YCBCR: return PIPE_FORMAT_UYVY; #if FEATURE_texture_s3tc @@ -214,6 +246,39 @@ st_mesa_format_to_pipe_format(gl_format mesaFormat) case MESA_FORMAT_SARGB8: return PIPE_FORMAT_B8G8R8A8_SRGB; #endif + case MESA_FORMAT_RGBA_FLOAT32: + return PIPE_FORMAT_R32G32B32A32_FLOAT; + case MESA_FORMAT_RGBA_FLOAT16: + return PIPE_FORMAT_R16G16B16A16_FLOAT; + case MESA_FORMAT_RGB_FLOAT32: + return PIPE_FORMAT_R32G32B32_FLOAT; + case MESA_FORMAT_RGB_FLOAT16: + return PIPE_FORMAT_R16G16B16_FLOAT; + case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32: + return PIPE_FORMAT_L32A32_FLOAT; + case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16: + return PIPE_FORMAT_L16A16_FLOAT; + case MESA_FORMAT_LUMINANCE_FLOAT32: + return PIPE_FORMAT_L32_FLOAT; + case MESA_FORMAT_LUMINANCE_FLOAT16: + return PIPE_FORMAT_L16_FLOAT; + case MESA_FORMAT_ALPHA_FLOAT32: + return PIPE_FORMAT_A32_FLOAT; + case MESA_FORMAT_ALPHA_FLOAT16: + return PIPE_FORMAT_A16_FLOAT; + case MESA_FORMAT_INTENSITY_FLOAT32: + return PIPE_FORMAT_I32_FLOAT; + case MESA_FORMAT_INTENSITY_FLOAT16: + return PIPE_FORMAT_I16_FLOAT; + case MESA_FORMAT_R_FLOAT32: + return PIPE_FORMAT_R32_FLOAT; + case MESA_FORMAT_R_FLOAT16: + return PIPE_FORMAT_R16_FLOAT; + case MESA_FORMAT_RG_FLOAT32: + return PIPE_FORMAT_R32G32_FLOAT; + case MESA_FORMAT_RG_FLOAT16: + return PIPE_FORMAT_R16G16_FLOAT; + case MESA_FORMAT_R8: return PIPE_FORMAT_R8_UNORM; case MESA_FORMAT_R16: @@ -249,6 +314,54 @@ st_mesa_format_to_pipe_format(gl_format mesaFormat) return PIPE_FORMAT_RGTC2_UNORM; case MESA_FORMAT_SIGNED_RG_RGTC2: return PIPE_FORMAT_RGTC2_SNORM; + + case MESA_FORMAT_L_LATC1: + return PIPE_FORMAT_LATC1_UNORM; + case MESA_FORMAT_SIGNED_L_LATC1: + return PIPE_FORMAT_LATC1_SNORM; + case MESA_FORMAT_LA_LATC2: + return PIPE_FORMAT_LATC2_UNORM; + case MESA_FORMAT_SIGNED_LA_LATC2: + return PIPE_FORMAT_LATC2_SNORM; + + /* signed normalized formats */ + case MESA_FORMAT_SIGNED_R8: + return PIPE_FORMAT_R8_SNORM; + case MESA_FORMAT_SIGNED_RG88_REV: + return PIPE_FORMAT_R8G8_SNORM; + case MESA_FORMAT_SIGNED_RGBA8888_REV: + return PIPE_FORMAT_R8G8B8A8_SNORM; + + case MESA_FORMAT_SIGNED_A8: + return PIPE_FORMAT_A8_SNORM; + case MESA_FORMAT_SIGNED_L8: + return PIPE_FORMAT_L8_SNORM; + case MESA_FORMAT_SIGNED_AL88: + return PIPE_FORMAT_L8A8_SNORM; + case MESA_FORMAT_SIGNED_I8: + return PIPE_FORMAT_I8_SNORM; + + case MESA_FORMAT_SIGNED_R16: + return PIPE_FORMAT_R16_SNORM; + case MESA_FORMAT_SIGNED_GR1616: + return PIPE_FORMAT_R16G16_SNORM; + case MESA_FORMAT_SIGNED_RGBA_16: + return PIPE_FORMAT_R16G16B16A16_SNORM; + + case MESA_FORMAT_SIGNED_A16: + return PIPE_FORMAT_A16_SNORM; + case MESA_FORMAT_SIGNED_L16: + return PIPE_FORMAT_L16_SNORM; + case MESA_FORMAT_SIGNED_AL1616: + return PIPE_FORMAT_L16A16_SNORM; + case MESA_FORMAT_SIGNED_I16: + return PIPE_FORMAT_I16_SNORM; + + case MESA_FORMAT_RGB9_E5_FLOAT: + return PIPE_FORMAT_R9G9B9E5_FLOAT; + case MESA_FORMAT_R11_G11_B10_FLOAT: + return PIPE_FORMAT_R11G11B10_FLOAT; + default: assert(0); return PIPE_FORMAT_NONE; @@ -308,8 +421,6 @@ st_pipe_format_to_mesa_format(enum pipe_format format) case PIPE_FORMAT_R16G16B16A16_UNORM: return MESA_FORMAT_RGBA_16; - case PIPE_FORMAT_R16G16B16A16_SNORM: - return MESA_FORMAT_SIGNED_RGBA_16; case PIPE_FORMAT_Z16_UNORM: return MESA_FORMAT_Z16; @@ -323,6 +434,10 @@ st_pipe_format_to_mesa_format(enum pipe_format format) return MESA_FORMAT_X8_Z24; case PIPE_FORMAT_Z24_UNORM_S8_USCALED: return MESA_FORMAT_S8_Z24; + case PIPE_FORMAT_Z32_FLOAT: + return MESA_FORMAT_Z32_FLOAT; + case PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED: + return MESA_FORMAT_Z32_FLOAT_X24S8; case PIPE_FORMAT_UYVY: return MESA_FORMAT_YCBCR; @@ -362,6 +477,38 @@ st_pipe_format_to_mesa_format(enum pipe_format format) case PIPE_FORMAT_B8G8R8A8_SRGB: return MESA_FORMAT_SARGB8; #endif + case PIPE_FORMAT_R32G32B32A32_FLOAT: + return MESA_FORMAT_RGBA_FLOAT32; + case PIPE_FORMAT_R16G16B16A16_FLOAT: + return MESA_FORMAT_RGBA_FLOAT16; + case PIPE_FORMAT_R32G32B32_FLOAT: + return MESA_FORMAT_RGB_FLOAT32; + case PIPE_FORMAT_R16G16B16_FLOAT: + return MESA_FORMAT_RGB_FLOAT16; + case PIPE_FORMAT_L32A32_FLOAT: + return MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32; + case PIPE_FORMAT_L16A16_FLOAT: + return MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16; + case PIPE_FORMAT_L32_FLOAT: + return MESA_FORMAT_LUMINANCE_FLOAT32; + case PIPE_FORMAT_L16_FLOAT: + return MESA_FORMAT_LUMINANCE_FLOAT16; + case PIPE_FORMAT_A32_FLOAT: + return MESA_FORMAT_ALPHA_FLOAT32; + case PIPE_FORMAT_A16_FLOAT: + return MESA_FORMAT_ALPHA_FLOAT16; + case PIPE_FORMAT_I32_FLOAT: + return MESA_FORMAT_INTENSITY_FLOAT32; + case PIPE_FORMAT_I16_FLOAT: + return MESA_FORMAT_INTENSITY_FLOAT16; + case PIPE_FORMAT_R32_FLOAT: + return MESA_FORMAT_R_FLOAT32; + case PIPE_FORMAT_R16_FLOAT: + return MESA_FORMAT_R_FLOAT16; + case PIPE_FORMAT_R32G32_FLOAT: + return MESA_FORMAT_RG_FLOAT32; + case PIPE_FORMAT_R16G16_FLOAT: + return MESA_FORMAT_RG_FLOAT16; case PIPE_FORMAT_R8_UNORM: return MESA_FORMAT_R8; @@ -397,6 +544,53 @@ st_pipe_format_to_mesa_format(enum pipe_format format) case PIPE_FORMAT_RGTC2_SNORM: return MESA_FORMAT_SIGNED_RG_RGTC2; + case PIPE_FORMAT_LATC1_UNORM: + return MESA_FORMAT_L_LATC1; + case PIPE_FORMAT_LATC1_SNORM: + return MESA_FORMAT_SIGNED_L_LATC1; + case PIPE_FORMAT_LATC2_UNORM: + return MESA_FORMAT_LA_LATC2; + case PIPE_FORMAT_LATC2_SNORM: + return MESA_FORMAT_SIGNED_LA_LATC2; + + /* signed normalized formats */ + case PIPE_FORMAT_R8_SNORM: + return MESA_FORMAT_SIGNED_R8; + case PIPE_FORMAT_R8G8_SNORM: + return MESA_FORMAT_SIGNED_RG88_REV; + case PIPE_FORMAT_R8G8B8A8_SNORM: + return MESA_FORMAT_SIGNED_RGBA8888_REV; + + case PIPE_FORMAT_A8_SNORM: + return MESA_FORMAT_SIGNED_A8; + case PIPE_FORMAT_L8_SNORM: + return MESA_FORMAT_SIGNED_L8; + case PIPE_FORMAT_L8A8_SNORM: + return MESA_FORMAT_SIGNED_AL88; + case PIPE_FORMAT_I8_SNORM: + return MESA_FORMAT_SIGNED_I8; + + case PIPE_FORMAT_R16_SNORM: + return MESA_FORMAT_SIGNED_R16; + case PIPE_FORMAT_R16G16_SNORM: + return MESA_FORMAT_SIGNED_GR1616; + case PIPE_FORMAT_R16G16B16A16_SNORM: + return MESA_FORMAT_SIGNED_RGBA_16; + + case PIPE_FORMAT_A16_SNORM: + return MESA_FORMAT_SIGNED_A16; + case PIPE_FORMAT_L16_SNORM: + return MESA_FORMAT_SIGNED_L16; + case PIPE_FORMAT_L16A16_SNORM: + return MESA_FORMAT_SIGNED_AL1616; + case PIPE_FORMAT_I16_SNORM: + return MESA_FORMAT_SIGNED_I16; + + case PIPE_FORMAT_R9G9B9E5_FLOAT: + return MESA_FORMAT_RGB9_E5_FLOAT; + case PIPE_FORMAT_R11G11B10_FLOAT: + return MESA_FORMAT_R11_G11_B10_FLOAT; + default: assert(0); return MESA_FORMAT_NONE; @@ -404,92 +598,661 @@ st_pipe_format_to_mesa_format(enum pipe_format format) } +/** + * Map GL texture formats to Gallium pipe formats. + */ +struct format_mapping +{ + GLenum glFormats[18]; /**< list of GLenum formats, 0-terminated */ + enum pipe_format pipeFormats[10]; /**< list of pipe formats, 0-terminated */ +}; + + +#define DEFAULT_RGBA_FORMATS \ + PIPE_FORMAT_B8G8R8A8_UNORM, \ + PIPE_FORMAT_A8R8G8B8_UNORM, \ + PIPE_FORMAT_A8B8G8R8_UNORM, \ + PIPE_FORMAT_B5G6R5_UNORM, \ + 0 + +#define DEFAULT_RGB_FORMATS \ + PIPE_FORMAT_B8G8R8X8_UNORM, \ + PIPE_FORMAT_X8R8G8B8_UNORM, \ + PIPE_FORMAT_X8B8G8R8_UNORM, \ + PIPE_FORMAT_B8G8R8A8_UNORM, \ + PIPE_FORMAT_A8R8G8B8_UNORM, \ + PIPE_FORMAT_A8B8G8R8_UNORM, \ + PIPE_FORMAT_B5G6R5_UNORM, \ + 0 + +#define DEFAULT_SRGBA_FORMATS \ + PIPE_FORMAT_B8G8R8A8_SRGB, \ + PIPE_FORMAT_A8R8G8B8_SRGB, \ + PIPE_FORMAT_A8B8G8R8_SRGB, \ + 0 + +#define DEFAULT_DEPTH_FORMATS \ + PIPE_FORMAT_Z24X8_UNORM, \ + PIPE_FORMAT_X8Z24_UNORM, \ + PIPE_FORMAT_Z16_UNORM, \ + PIPE_FORMAT_Z24_UNORM_S8_USCALED, \ + PIPE_FORMAT_S8_USCALED_Z24_UNORM, \ + 0 + +/** + * This table maps OpenGL texture format enums to Gallium pipe_format enums. + * Multiple GL enums might map to multiple pipe_formats. + * The first pipe format in the list that's supported is the one that's chosen. + */ +static const struct format_mapping format_map[] = { + /* Basic RGB, RGBA formats */ + { + { GL_RGB10, GL_RGB10_A2, 0 }, + { PIPE_FORMAT_B10G10R10A2_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { 4, GL_RGBA, GL_RGBA8, 0 }, + { PIPE_FORMAT_R8G8B8A8_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_BGRA, 0 }, + { PIPE_FORMAT_B8G8R8A8_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { 3, GL_RGB, GL_RGB8, 0 }, + { DEFAULT_RGB_FORMATS } + }, + { + { GL_RGB12, GL_RGB16, GL_RGBA12, GL_RGBA16, 0 }, + { PIPE_FORMAT_R16G16B16A16_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_RGBA4, GL_RGBA2, 0 }, + { PIPE_FORMAT_B4G4R4A4_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_RGB5_A1, 0 }, + { PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_R3_G3_B2, 0 }, + { PIPE_FORMAT_B2G3R3_UNORM, PIPE_FORMAT_B5G6R5_UNORM, + PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_RGB5, GL_RGB4 }, + { PIPE_FORMAT_B5G6R5_UNORM, PIPE_FORMAT_B5G5R5A1_UNORM, + DEFAULT_RGBA_FORMATS } + }, + + /* basic Alpha formats */ + { + { GL_ALPHA12, GL_ALPHA16, 0 }, + { PIPE_FORMAT_A16_UNORM, PIPE_FORMAT_A8_UNORM, + DEFAULT_RGBA_FORMATS } + }, + { + { GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_COMPRESSED_ALPHA, 0 }, + { PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS } + }, + + /* basic Luminance formats */ + { + { GL_LUMINANCE12, GL_LUMINANCE16, 0 }, + { PIPE_FORMAT_L16_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS } + }, + { + { 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 }, + { PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS } + }, + + /* basic Luminance/Alpha formats */ + { + { GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, + GL_LUMINANCE16_ALPHA16, 0}, + { PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_L8A8_UNORM, + DEFAULT_RGBA_FORMATS } + }, + { + { 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 }, + { PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_LUMINANCE4_ALPHA4, 0 }, + { PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM, + DEFAULT_RGBA_FORMATS } + }, + + /* basic Intensity formats */ + { + { GL_INTENSITY12, GL_INTENSITY16, 0 }, + { PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS } + }, + { + { GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, + GL_COMPRESSED_INTENSITY, 0 }, + { PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS } + }, + + /* YCbCr */ + { + { GL_YCBCR_MESA, 0 }, + { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 } + }, + + /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */ + { + { GL_COMPRESSED_RGB, 0 }, + { PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS } + }, + { + { GL_COMPRESSED_RGBA, 0 }, + { PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS } + }, + { + { GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 }, + { PIPE_FORMAT_DXT1_RGB, 0 } + }, + { + { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 }, + { PIPE_FORMAT_DXT1_RGBA, 0 } + }, + { + { GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 }, + { PIPE_FORMAT_DXT3_RGBA, 0 } + }, + { + { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 }, + { PIPE_FORMAT_DXT5_RGBA, 0 } + }, + +#if 0 + { + { GL_COMPRESSED_RGB_FXT1_3DFX, 0 }, + { PIPE_FORMAT_RGB_FXT1, 0 } + }, + { + { GL_COMPRESSED_RGBA_FXT1_3DFX, 0 }, + { PIPE_FORMAT_RGBA_FXT1, 0 } + }, +#endif + + /* Depth formats */ + { + { GL_DEPTH_COMPONENT16, 0 }, + { PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS } + }, + { + { GL_DEPTH_COMPONENT24, 0 }, + { PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM, + DEFAULT_DEPTH_FORMATS } + }, + { + { GL_DEPTH_COMPONENT32, 0 }, + { PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS } + }, + { + { GL_DEPTH_COMPONENT, 0 }, + { DEFAULT_DEPTH_FORMATS } + }, + { + { GL_DEPTH_COMPONENT32F, 0 }, + { PIPE_FORMAT_Z32_FLOAT, 0 } + }, + + /* stencil formats */ + { + { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT, + GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 }, + { + PIPE_FORMAT_S8_USCALED, PIPE_FORMAT_Z24_UNORM_S8_USCALED, + PIPE_FORMAT_S8_USCALED_Z24_UNORM, 0 + } + }, + + /* Depth / Stencil formats */ + { + { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 }, + { PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_FORMAT_S8_USCALED_Z24_UNORM, 0 } + }, + { + { GL_DEPTH32F_STENCIL8, 0 }, + { PIPE_FORMAT_Z32_FLOAT_S8X24_USCALED, 0 } + }, + + /* sRGB formats */ + { + { GL_SRGB_EXT, GL_SRGB8_EXT, GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 }, + { DEFAULT_SRGBA_FORMATS } + }, + { + { GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 }, + { PIPE_FORMAT_DXT1_SRGB, DEFAULT_SRGBA_FORMATS } + }, + { + { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 }, + { PIPE_FORMAT_DXT1_SRGBA, 0 } + }, + { + { GL_COMPRESSED_SRGB_ALPHA_EXT, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 }, + { PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS } + }, + { + { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 }, + { PIPE_FORMAT_DXT5_SRGBA, 0 } + }, + { + { GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT, + GL_COMPRESSED_SLUMINANCE_EXT, GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 }, + { PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS } + }, + { + { GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, 0 }, + { PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS } + }, + + /* 16-bit float formats */ + { + { GL_RGBA16F_ARB, 0 }, + { PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_RGB16F_ARB, 0 }, + { PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_LUMINANCE_ALPHA16F_ARB, 0 }, + { PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_ALPHA16F_ARB, 0 }, + { PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT, + PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_INTENSITY16F_ARB, 0 }, + { PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT, + PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_LUMINANCE16F_ARB, 0 }, + { PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT, + PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_R16F, 0 }, + { PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT, + PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + { + { GL_RG16F, 0 }, + { PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, + PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 } + }, + + /* 32-bit float formats */ + { + { GL_RGBA32F_ARB, 0 }, + { PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_RGB32F_ARB, 0 }, + { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, + PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_LUMINANCE_ALPHA32F_ARB, 0 }, + { PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, + PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_ALPHA32F_ARB, 0 }, + { PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT, + PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_A16_FLOAT, + PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_INTENSITY32F_ARB, 0 }, + { PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT, + PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_I16_FLOAT, + PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_LUMINANCE32F_ARB, 0 }, + { PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT, + PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_L16_FLOAT, + PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_R32F, 0 }, + { PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT, + PIPE_FORMAT_R32G32B32A32_FLOAT, PIPE_FORMAT_R16_FLOAT, + PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + { + { GL_RG32F, 0 }, + { PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, + PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT, 0 } + }, + + /* R, RG formats */ + { + { GL_RED, GL_R8, 0 }, + { PIPE_FORMAT_R8_UNORM, 0 } + }, + { + { GL_RG, GL_RG8, 0 }, + { PIPE_FORMAT_R8G8_UNORM, 0 } + }, + { + { GL_R16, 0 }, + { PIPE_FORMAT_R16_UNORM, 0 } + }, + { + { GL_RG16, 0 }, + { PIPE_FORMAT_R16G16_UNORM, 0 } + }, + + /* compressed R, RG formats */ + { + { GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 }, + { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, 0 } + }, + { + { GL_COMPRESSED_SIGNED_RED_RGTC1, 0 }, + { PIPE_FORMAT_RGTC1_SNORM, 0 } + }, + { + { GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 }, + { PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, 0 } + }, + { + { GL_COMPRESSED_SIGNED_RG_RGTC2, 0 }, + { PIPE_FORMAT_RGTC2_SNORM, 0 } + }, + { + { GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 }, + { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, 0 } + }, + { + { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 }, + { PIPE_FORMAT_LATC1_SNORM, 0 } + }, + { + { GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, + GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 }, + { PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, 0 } + }, + { + { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 }, + { PIPE_FORMAT_LATC2_SNORM, 0 } + }, + + /* signed/unsigned integer formats. + * XXX Mesa only has formats for RGBA signed/unsigned integer formats. + * If/when new formats are added this code should be updated. + */ + { + { GL_RED_INTEGER_EXT, + GL_GREEN_INTEGER_EXT, + GL_BLUE_INTEGER_EXT, + GL_ALPHA_INTEGER_EXT, + GL_RGB_INTEGER_EXT, + GL_RGBA_INTEGER_EXT, + GL_BGR_INTEGER_EXT, + GL_BGRA_INTEGER_EXT, + GL_LUMINANCE_INTEGER_EXT, + GL_LUMINANCE_ALPHA_INTEGER_EXT, + GL_RGBA8I_EXT, + GL_RGB8I_EXT, + GL_ALPHA8I_EXT, + GL_INTENSITY8I_EXT, + GL_LUMINANCE8I_EXT, + GL_LUMINANCE_ALPHA8I_EXT, 0 }, + { PIPE_FORMAT_R8G8B8A8_SSCALED, 0 } + }, + { + { + GL_RGBA16I_EXT, + GL_RGB16I_EXT, + GL_ALPHA16I_EXT, + GL_INTENSITY16I_EXT, + GL_LUMINANCE16I_EXT, + GL_LUMINANCE_ALPHA16I_EXT, 0 }, + { PIPE_FORMAT_R16G16B16A16_SSCALED, 0 }, + }, + { + { + GL_RGBA32I_EXT, + GL_RGB32I_EXT, + GL_ALPHA32I_EXT, + GL_INTENSITY32I_EXT, + GL_LUMINANCE32I_EXT, + GL_LUMINANCE_ALPHA32I_EXT, 0 }, + { PIPE_FORMAT_R32G32B32A32_SSCALED, 0 } + }, + { + { + GL_RGBA8UI_EXT, + GL_RGB8UI_EXT, + GL_ALPHA8UI_EXT, + GL_INTENSITY8UI_EXT, + GL_LUMINANCE8UI_EXT, + GL_LUMINANCE_ALPHA8UI_EXT, 0 }, + { PIPE_FORMAT_R8G8B8A8_USCALED, 0 } + }, + { + { + GL_RGBA16UI_EXT, + GL_RGB16UI_EXT, + GL_ALPHA16UI_EXT, + GL_INTENSITY16UI_EXT, + GL_LUMINANCE16UI_EXT, + GL_LUMINANCE_ALPHA16UI_EXT, 0 }, + { PIPE_FORMAT_R16G16B16A16_USCALED, 0 } + }, + { + { + GL_RGBA32UI_EXT, + GL_RGB32UI_EXT, + GL_ALPHA32UI_EXT, + GL_INTENSITY32UI_EXT, + GL_LUMINANCE32UI_EXT, + GL_LUMINANCE_ALPHA32UI_EXT, 0 }, + { PIPE_FORMAT_R32G32B32A32_USCALED, 0 } + }, + + /* signed normalized formats */ + { + { GL_RED_SNORM, GL_R8_SNORM, 0 }, + { PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM, + PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_R16_SNORM, 0 }, + { PIPE_FORMAT_R16_SNORM, + PIPE_FORMAT_R16G16_SNORM, + PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_R8_SNORM, + PIPE_FORMAT_R8G8_SNORM, + PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_RG_SNORM, GL_RG8_SNORM, 0 }, + { PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_RG16_SNORM, 0 }, + { PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_RGB_SNORM, GL_RGB8_SNORM, GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 }, + { PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_RGB16_SNORM, GL_RGBA16_SNORM, 0 }, + { PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 }, + { PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_ALPHA16_SNORM, 0 }, + { PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 }, + { PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_LUMINANCE16_SNORM, 0 }, + { PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 }, + { PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_LUMINANCE16_ALPHA16_SNORM, 0 }, + { PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 }, + { PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_INTENSITY16_SNORM, 0 }, + { PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM, + PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 } + }, + { + { GL_RGB9_E5, 0 }, + { PIPE_FORMAT_R9G9B9E5_FLOAT, 0 } + }, + { + { GL_R11F_G11F_B10F, 0 }, + { PIPE_FORMAT_R11G11B10_FLOAT, 0 } + } +}; + + /** * Return first supported format from the given list. */ static enum pipe_format -find_supported_format(struct pipe_screen *screen, +find_supported_format(struct pipe_screen *screen, const enum pipe_format formats[], - uint num_formats, enum pipe_texture_target target, unsigned sample_count, - unsigned tex_usage, - unsigned geom_flags) + unsigned tex_usage) { uint i; - for (i = 0; i < num_formats; i++) { + for (i = 0; formats[i]; i++) { if (screen->is_format_supported(screen, formats[i], target, - sample_count, tex_usage, geom_flags)) { + sample_count, tex_usage)) { return formats[i]; } } return PIPE_FORMAT_NONE; } - -/** - * Find an RGBA format supported by the context/winsys. - */ -static enum pipe_format -default_rgba_format(struct pipe_screen *screen, - enum pipe_texture_target target, - unsigned sample_count, - unsigned tex_usage, - unsigned geom_flags) +struct exact_format_mapping { - static const enum pipe_format colorFormats[] = { - PIPE_FORMAT_B8G8R8A8_UNORM, - PIPE_FORMAT_A8R8G8B8_UNORM, - PIPE_FORMAT_A8B8G8R8_UNORM, - PIPE_FORMAT_B5G6R5_UNORM - }; - return find_supported_format(screen, colorFormats, Elements(colorFormats), - target, sample_count, tex_usage, geom_flags); -} - + GLenum format; + GLenum type; + enum pipe_format pformat; +}; -/** - * Find an RGB format supported by the context/winsys. - */ -static enum pipe_format -default_rgb_format(struct pipe_screen *screen, - enum pipe_texture_target target, - unsigned sample_count, - unsigned tex_usage, - unsigned geom_flags) +static const struct exact_format_mapping rgba8888_tbl[] = { - static const enum pipe_format colorFormats[] = { - PIPE_FORMAT_B8G8R8X8_UNORM, - PIPE_FORMAT_X8R8G8B8_UNORM, - PIPE_FORMAT_X8B8G8R8_UNORM, - PIPE_FORMAT_B8G8R8A8_UNORM, - PIPE_FORMAT_A8R8G8B8_UNORM, - PIPE_FORMAT_A8B8G8R8_UNORM, - PIPE_FORMAT_B5G6R5_UNORM - }; - return find_supported_format(screen, colorFormats, Elements(colorFormats), - target, sample_count, tex_usage, geom_flags); -} + { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_A8B8G8R8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_A8B8G8R8_UNORM }, + { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_R8G8B8A8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_R8G8B8A8_UNORM }, + { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_A8R8G8B8_UNORM }, + { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_B8G8R8A8_UNORM }, + { GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8A8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_A8B8G8R8_UNORM }, + { GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8A8_UNORM }, + { 0, 0, 0 } +}; + +static const struct exact_format_mapping rgbx8888_tbl[] = +{ + { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_X8R8G8B8_UNORM }, + { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_B8G8R8X8_UNORM }, + { GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8X8_UNORM }, + /* No Mesa formats for these Gallium formats: + { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_X8B8G8R8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_X8B8G8R8_UNORM }, + { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_R8G8B8X8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_R8G8B8X8_UNORM }, + { GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8X8_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_X8B8G8R8_UNORM }, + */ + { 0, 0, 0 } +}; + +static const struct exact_format_mapping rgba1010102_tbl[] = +{ + { GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_B10G10R10A2_UNORM }, + /* No Mesa formats for these Gallium formats: + { GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, PIPE_FORMAT_R10G10B10A2_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT_10_10_10_2, PIPE_FORMAT_R10G10B10A2_UNORM }, + { GL_ABGR_EXT, GL_UNSIGNED_INT, PIPE_FORMAT_R10G10B10A2_UNORM }, + */ + { 0, 0, 0 } +}; /** - * Find an sRGBA format supported by the context/winsys. + * If there is an exact pipe_format match for {internalFormat, format, type} + * return that, otherwise return PIPE_FORMAT_NONE so we can do fuzzy matching. */ static enum pipe_format -default_srgba_format(struct pipe_screen *screen, - enum pipe_texture_target target, - unsigned sample_count, - unsigned tex_usage, - unsigned geom_flags) +find_exact_format(GLint internalFormat, GLenum format, GLenum type) { - static const enum pipe_format colorFormats[] = { - PIPE_FORMAT_B8G8R8A8_SRGB, - PIPE_FORMAT_A8R8G8B8_SRGB, - PIPE_FORMAT_A8B8G8R8_SRGB, - }; - return find_supported_format(screen, colorFormats, Elements(colorFormats), - target, sample_count, tex_usage, geom_flags); -} + uint i; + const struct exact_format_mapping* tbl; + if (format == GL_NONE || type == GL_NONE) + return PIPE_FORMAT_NONE; + + switch (internalFormat) { + case 4: + case GL_RGBA: + case GL_RGBA8: + tbl = rgba8888_tbl; + break; + case 3: + case GL_RGB: + case GL_RGB8: + tbl = rgbx8888_tbl; + break; + case GL_RGB10_A2: + tbl = rgba1010102_tbl; + break; + default: + return PIPE_FORMAT_NONE; + } + + for (i = 0; tbl[i].format; i++) + if (tbl[i].format == format && tbl[i].type == type) + return tbl[i].pformat; + + return PIPE_FORMAT_NONE; +} /** * Given an OpenGL internalFormat value for a texture or surface, return @@ -506,490 +1269,43 @@ default_srgba_format(struct pipe_screen *screen, */ enum pipe_format st_choose_format(struct pipe_screen *screen, GLenum internalFormat, + GLenum format, GLenum type, enum pipe_texture_target target, unsigned sample_count, unsigned bindings) { - unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */ + GET_CURRENT_CONTEXT(ctx); /* XXX this should be a function parameter */ + int i, j; + enum pipe_format pf; - switch (internalFormat) { - case GL_RGB10: - case GL_RGB10_A2: - if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B10G10R10A2_UNORM; - /* Pass through. */ - case 4: - case GL_RGBA: - case GL_RGBA8: - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_BGRA: - if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B8G8R8A8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case 3: - case GL_RGB: - case GL_RGB8: - return default_rgb_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_RGB12: - case GL_RGB16: - case GL_RGBA12: - case GL_RGBA16: - if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_R16G16B16A16_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_RGBA4: - case GL_RGBA2: - if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B4G4R4A4_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_RGB5_A1: - if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B5G5R5A1_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_R3_G3_B2: - if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B2G3R3_UNORM; - /* Pass through. */ - case GL_RGB5: - case GL_RGB4: - if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B5G6R5_UNORM; - if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM, - target, sample_count, bindings, - geom_flags )) - return PIPE_FORMAT_B5G5R5A1_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_ALPHA12: - case GL_ALPHA16: - if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_A16_UNORM; - /* Pass through. */ - case GL_ALPHA: - case GL_ALPHA4: - case GL_ALPHA8: - case GL_COMPRESSED_ALPHA: - if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_A8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_LUMINANCE12: - case GL_LUMINANCE16: - if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L16_UNORM; - /* Pass through. */ - case 1: - case GL_LUMINANCE: - case GL_LUMINANCE4: - case GL_LUMINANCE8: - case GL_COMPRESSED_LUMINANCE: - if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_LUMINANCE12_ALPHA4: - case GL_LUMINANCE12_ALPHA12: - case GL_LUMINANCE16_ALPHA16: - if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L16A16_UNORM; - /* Pass through. */ - case 2: - case GL_LUMINANCE_ALPHA: - case GL_LUMINANCE6_ALPHA2: - case GL_LUMINANCE8_ALPHA8: - case GL_COMPRESSED_LUMINANCE_ALPHA: - if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L8A8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_LUMINANCE4_ALPHA4: - if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L4A4_UNORM; - if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_L8A8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_INTENSITY12: - case GL_INTENSITY16: - if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_I16_UNORM; - /* Pass through. */ - case GL_INTENSITY: - case GL_INTENSITY4: - case GL_INTENSITY8: - case GL_COMPRESSED_INTENSITY: - if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target, - sample_count, bindings, geom_flags )) - return PIPE_FORMAT_I8_UNORM; - return default_rgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_YCBCR_MESA: - if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target, - sample_count, bindings, geom_flags)) { - return PIPE_FORMAT_UYVY; - } - if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target, - sample_count, bindings, geom_flags)) { - return PIPE_FORMAT_YUYV; - } + /* can't render to compressed formats at this time */ + if (_mesa_is_compressed_format(ctx, internalFormat) + && (bindings & ~PIPE_BIND_SAMPLER_VIEW)) { return PIPE_FORMAT_NONE; + } - case GL_COMPRESSED_RGB: - /* can only sample from compressed formats */ - if (bindings & ~PIPE_BIND_SAMPLER_VIEW) - return PIPE_FORMAT_NONE; - else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT1_RGB; - else - return default_rgb_format(screen, target, sample_count, bindings, - geom_flags); - - case GL_COMPRESSED_RGBA: - /* can only sample from compressed formats */ - if (bindings & ~PIPE_BIND_SAMPLER_VIEW) - return PIPE_FORMAT_NONE; - else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT3_RGBA; - else - return default_rgba_format(screen, target, sample_count, bindings, - geom_flags); - - case GL_RGB_S3TC: - case GL_RGB4_S3TC: - case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT1_RGB; - else - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT1_RGBA; - else - return PIPE_FORMAT_NONE; - - case GL_RGBA_S3TC: - case GL_RGBA4_S3TC: - case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT3_RGBA; - else - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA, - target, sample_count, bindings, - geom_flags)) - return PIPE_FORMAT_DXT5_RGBA; - else - return PIPE_FORMAT_NONE; - -#if 0 - case GL_COMPRESSED_RGB_FXT1_3DFX: - return PIPE_FORMAT_RGB_FXT1; - case GL_COMPRESSED_RGBA_FXT1_3DFX: - return PIPE_FORMAT_RGB_FXT1; -#endif - - case GL_DEPTH_COMPONENT16: - if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_Z16_UNORM; - /* fall-through */ - case GL_DEPTH_COMPONENT24: - if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED, - target, sample_count, bindings, geom_flags)) - return PIPE_FORMAT_Z24_UNORM_S8_USCALED; - if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM, - target, sample_count, bindings, geom_flags)) - return PIPE_FORMAT_S8_USCALED_Z24_UNORM; - /* fall-through */ - case GL_DEPTH_COMPONENT32: - if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_Z32_UNORM; - /* fall-through */ - case GL_DEPTH_COMPONENT: - { - static const enum pipe_format formats[] = { - PIPE_FORMAT_Z32_UNORM, - PIPE_FORMAT_Z24_UNORM_S8_USCALED, - PIPE_FORMAT_S8_USCALED_Z24_UNORM, - PIPE_FORMAT_Z16_UNORM - }; - return find_supported_format(screen, formats, Elements(formats), - target, sample_count, bindings, geom_flags); - } - - case GL_STENCIL_INDEX: - case GL_STENCIL_INDEX1_EXT: - case GL_STENCIL_INDEX4_EXT: - case GL_STENCIL_INDEX8_EXT: - case GL_STENCIL_INDEX16_EXT: - { - static const enum pipe_format formats[] = { - PIPE_FORMAT_S8_USCALED, - PIPE_FORMAT_Z24_UNORM_S8_USCALED, - PIPE_FORMAT_S8_USCALED_Z24_UNORM - }; - return find_supported_format(screen, formats, Elements(formats), - target, sample_count, bindings, geom_flags); - } - - case GL_DEPTH_STENCIL_EXT: - case GL_DEPTH24_STENCIL8_EXT: - { - static const enum pipe_format formats[] = { - PIPE_FORMAT_Z24_UNORM_S8_USCALED, - PIPE_FORMAT_S8_USCALED_Z24_UNORM - }; - return find_supported_format(screen, formats, Elements(formats), - target, sample_count, bindings, geom_flags); + /* search for exact matches */ + pf = find_exact_format(internalFormat, format, type); + if (pf != PIPE_FORMAT_NONE && + screen->is_format_supported(screen, pf, + target, sample_count, bindings)) + return pf; + + /* search table for internalFormat */ + for (i = 0; i < Elements(format_map); i++) { + const struct format_mapping *mapping = &format_map[i]; + for (j = 0; mapping->glFormats[j]; j++) { + if (mapping->glFormats[j] == internalFormat) { + /* Found the desired internal format. Find first pipe format + * which is supported by the driver. + */ + return find_supported_format(screen, mapping->pipeFormats, + target, sample_count, bindings); + } } - - case GL_SRGB_EXT: - case GL_SRGB8_EXT: - case GL_SRGB_ALPHA_EXT: - case GL_SRGB8_ALPHA8_EXT: - return default_srgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_COMPRESSED_SRGB_EXT: - case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_DXT1_SRGB; - return default_srgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: - return PIPE_FORMAT_DXT1_SRGBA; - - case GL_COMPRESSED_SRGB_ALPHA_EXT: - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_DXT3_SRGBA; - return default_srgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: - return PIPE_FORMAT_DXT5_SRGBA; - - case GL_SLUMINANCE_ALPHA_EXT: - case GL_SLUMINANCE8_ALPHA8_EXT: - case GL_COMPRESSED_SLUMINANCE_EXT: - case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_L8A8_SRGB; - return default_srgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_SLUMINANCE_EXT: - case GL_SLUMINANCE8_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_L8_SRGB; - return default_srgba_format( screen, target, sample_count, bindings, - geom_flags ); - - case GL_RED: - case GL_R8: - if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8_UNORM; - return PIPE_FORMAT_NONE; - case GL_RG: - case GL_RG8: - if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8G8_UNORM; - return PIPE_FORMAT_NONE; - - case GL_R16: - if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R16_UNORM; - return PIPE_FORMAT_NONE; - - case GL_RG16: - if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R16G16_UNORM; - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_RED: - case GL_COMPRESSED_RED_RGTC1: - if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_RGTC1_UNORM; - if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8_UNORM; - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_SIGNED_RED_RGTC1: - if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_RGTC1_SNORM; - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_RG: - case GL_COMPRESSED_RG_RGTC2: - if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_RGTC2_UNORM; - if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8G8_UNORM; - return PIPE_FORMAT_NONE; - - case GL_COMPRESSED_SIGNED_RG_RGTC2: - if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_RGTC2_SNORM; - return PIPE_FORMAT_NONE; - - /* signed/unsigned integer formats. - * XXX Mesa only has formats for RGBA signed/unsigned integer formats. - * If/when new formats are added this code should be updated. - */ - 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: - /* fall-through */ - case GL_RGBA8I_EXT: - case GL_RGB8I_EXT: - case GL_ALPHA8I_EXT: - case GL_INTENSITY8I_EXT: - case GL_LUMINANCE8I_EXT: - case GL_LUMINANCE_ALPHA8I_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8G8B8A8_SSCALED; - return PIPE_FORMAT_NONE; - case GL_RGBA16I_EXT: - case GL_RGB16I_EXT: - case GL_ALPHA16I_EXT: - case GL_INTENSITY16I_EXT: - case GL_LUMINANCE16I_EXT: - case GL_LUMINANCE_ALPHA16I_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R16G16B16A16_SSCALED; - return PIPE_FORMAT_NONE; - case GL_RGBA32I_EXT: - case GL_RGB32I_EXT: - case GL_ALPHA32I_EXT: - case GL_INTENSITY32I_EXT: - case GL_LUMINANCE32I_EXT: - case GL_LUMINANCE_ALPHA32I_EXT: - /* xxx */ - if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R32G32B32A32_SSCALED; - return PIPE_FORMAT_NONE; - - case GL_RGBA8UI_EXT: - case GL_RGB8UI_EXT: - case GL_ALPHA8UI_EXT: - case GL_INTENSITY8UI_EXT: - case GL_LUMINANCE8UI_EXT: - case GL_LUMINANCE_ALPHA8UI_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R8G8B8A8_USCALED; - return PIPE_FORMAT_NONE; - - case GL_RGBA16UI_EXT: - case GL_RGB16UI_EXT: - case GL_ALPHA16UI_EXT: - case GL_INTENSITY16UI_EXT: - case GL_LUMINANCE16UI_EXT: - case GL_LUMINANCE_ALPHA16UI_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R16G16B16A16_USCALED; - return PIPE_FORMAT_NONE; - - case GL_RGBA32UI_EXT: - case GL_RGB32UI_EXT: - case GL_ALPHA32UI_EXT: - case GL_INTENSITY32UI_EXT: - case GL_LUMINANCE32UI_EXT: - case GL_LUMINANCE_ALPHA32UI_EXT: - if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED, - target, - sample_count, bindings, geom_flags)) - return PIPE_FORMAT_R32G32B32A32_USCALED; - return PIPE_FORMAT_NONE; - - default: - return PIPE_FORMAT_NONE; } + + _mesa_problem(NULL, "unhandled format!\n"); + return PIPE_FORMAT_NONE; } @@ -1005,14 +1321,11 @@ st_choose_renderbuffer_format(struct pipe_screen *screen, usage = PIPE_BIND_DEPTH_STENCIL; else usage = PIPE_BIND_RENDER_TARGET; - return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D, + return st_choose_format(screen, internalFormat, GL_NONE, GL_NONE, PIPE_TEXTURE_2D, sample_count, usage); } -/** - * Called via ctx->Driver.chooseTextureFormat(). - */ gl_format st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat, GLenum format, GLenum type, GLboolean renderable) @@ -1028,20 +1341,19 @@ st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat, * that in advance. Specify potential render target flags now. */ bindings = PIPE_BIND_SAMPLER_VIEW; - if (renderable == GL_TRUE) { - if (_mesa_is_depth_format(internalFormat) || - _mesa_is_depth_or_stencil_format(internalFormat)) + if (renderable) { + if (_mesa_is_depth_or_stencil_format(internalFormat)) bindings |= PIPE_BIND_DEPTH_STENCIL; - else + else bindings |= PIPE_BIND_RENDER_TARGET; } - pFormat = st_choose_format(screen, internalFormat, + pFormat = st_choose_format(screen, internalFormat, format, type, PIPE_TEXTURE_2D, 0, bindings); if (pFormat == PIPE_FORMAT_NONE) { /* try choosing format again, this time without render target bindings */ - pFormat = st_choose_format(screen, internalFormat, + pFormat = st_choose_format(screen, internalFormat, format, type, PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW); } @@ -1053,6 +1365,10 @@ st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat, return st_pipe_format_to_mesa_format(pFormat); } + +/** + * Called via ctx->Driver.ChooseTextureFormat(). + */ gl_format st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat, GLenum format, GLenum type)