1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
4 * Copyright (c) 2008-2010 VMware, Inc.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 **************************************************************************/
31 * Mesa / Gallium format conversion and format selection code.
36 #include "main/context.h"
37 #include "main/enums.h"
38 #include "main/formats.h"
39 #include "main/glformats.h"
40 #include "main/texcompress.h"
41 #include "main/texgetimage.h"
42 #include "main/teximage.h"
43 #include "main/texstore.h"
44 #include "main/image.h"
45 #include "main/macros.h"
46 #include "main/formatquery.h"
48 #include "pipe/p_context.h"
49 #include "pipe/p_defines.h"
50 #include "pipe/p_screen.h"
51 #include "util/format/u_format.h"
52 #include "st_cb_texture.h"
53 #include "st_context.h"
54 #include "st_format.h"
55 #include "st_texture.h"
59 * Translate Mesa format to Gallium format.
62 st_mesa_format_to_pipe_format(const struct st_context
*st
,
63 mesa_format mesaFormat
)
65 struct pipe_screen
*screen
= st
->pipe
->screen
;
67 /* The destination RGBA format mustn't be changed, because it's also
68 * a destination format of the unpack/decompression function.
70 if (mesaFormat
== MESA_FORMAT_ETC1_RGB8
&& !st
->has_etc1
)
71 return PIPE_FORMAT_R8G8B8A8_UNORM
;
73 /* ETC2 formats are emulated as uncompressed ones.
74 * The destination formats mustn't be changed, because they are also
75 * destination formats of the unpack/decompression function.
77 if (_mesa_is_format_etc2(mesaFormat
) && !st
->has_etc2
) {
78 bool has_bgra_srgb
= screen
->is_format_supported(screen
,
79 PIPE_FORMAT_B8G8R8A8_SRGB
,
80 PIPE_TEXTURE_2D
, 0, 0,
81 PIPE_BIND_SAMPLER_VIEW
);
84 case MESA_FORMAT_ETC2_RGB8
:
85 return PIPE_FORMAT_R8G8B8A8_UNORM
;
86 case MESA_FORMAT_ETC2_SRGB8
:
87 return has_bgra_srgb
? PIPE_FORMAT_B8G8R8A8_SRGB
: PIPE_FORMAT_R8G8B8A8_SRGB
;
88 case MESA_FORMAT_ETC2_RGBA8_EAC
:
89 return PIPE_FORMAT_R8G8B8A8_UNORM
;
90 case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC
:
91 return has_bgra_srgb
? PIPE_FORMAT_B8G8R8A8_SRGB
: PIPE_FORMAT_R8G8B8A8_SRGB
;
92 case MESA_FORMAT_ETC2_R11_EAC
:
93 return PIPE_FORMAT_R16_UNORM
;
94 case MESA_FORMAT_ETC2_RG11_EAC
:
95 return PIPE_FORMAT_R16G16_UNORM
;
96 case MESA_FORMAT_ETC2_SIGNED_R11_EAC
:
97 return PIPE_FORMAT_R16_SNORM
;
98 case MESA_FORMAT_ETC2_SIGNED_RG11_EAC
:
99 return PIPE_FORMAT_R16G16_SNORM
;
100 case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1
:
101 return PIPE_FORMAT_R8G8B8A8_UNORM
;
102 case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1
:
103 return has_bgra_srgb
? PIPE_FORMAT_B8G8R8A8_SRGB
: PIPE_FORMAT_R8G8B8A8_SRGB
;
105 unreachable("Unknown ETC2 format");
109 if (st_astc_format_fallback(st
, mesaFormat
)) {
110 if (_mesa_is_format_srgb(mesaFormat
))
111 return PIPE_FORMAT_R8G8B8A8_SRGB
;
113 return PIPE_FORMAT_R8G8B8A8_UNORM
;
121 * Translate Gallium format to Mesa format.
124 st_pipe_format_to_mesa_format(enum pipe_format format
)
126 mesa_format mf
= format
;
127 if (!_mesa_get_format_name(mf
))
128 return MESA_FORMAT_NONE
;
133 * Map GL texture formats to Gallium pipe formats.
135 struct format_mapping
137 GLenum glFormats
[18]; /**< list of GLenum formats, 0-terminated */
138 enum pipe_format pipeFormats
[14]; /**< list of pipe formats, 0-terminated */
142 #define DEFAULT_RGBA_FORMATS \
143 PIPE_FORMAT_R8G8B8A8_UNORM, \
144 PIPE_FORMAT_B8G8R8A8_UNORM, \
145 PIPE_FORMAT_A8R8G8B8_UNORM, \
146 PIPE_FORMAT_A8B8G8R8_UNORM, \
149 #define DEFAULT_RGB_FORMATS \
150 PIPE_FORMAT_R8G8B8X8_UNORM, \
151 PIPE_FORMAT_B8G8R8X8_UNORM, \
152 PIPE_FORMAT_X8R8G8B8_UNORM, \
153 PIPE_FORMAT_X8B8G8R8_UNORM, \
154 PIPE_FORMAT_B5G6R5_UNORM, \
157 #define DEFAULT_SRGBA_FORMATS \
158 PIPE_FORMAT_R8G8B8A8_SRGB, \
159 PIPE_FORMAT_B8G8R8A8_SRGB, \
160 PIPE_FORMAT_A8R8G8B8_SRGB, \
161 PIPE_FORMAT_A8B8G8R8_SRGB, \
164 #define DEFAULT_DEPTH_FORMATS \
165 PIPE_FORMAT_Z24X8_UNORM, \
166 PIPE_FORMAT_X8Z24_UNORM, \
167 PIPE_FORMAT_Z16_UNORM, \
168 PIPE_FORMAT_Z24_UNORM_S8_UINT, \
169 PIPE_FORMAT_S8_UINT_Z24_UNORM, \
172 #define DEFAULT_SNORM8_RGBA_FORMATS \
173 PIPE_FORMAT_R8G8B8A8_SNORM, \
176 #define DEFAULT_UNORM16_RGBA_FORMATS \
177 PIPE_FORMAT_R16G16B16A16_UNORM, \
182 * This table maps OpenGL texture format enums to Gallium pipe_format enums.
183 * Multiple GL enums might map to multiple pipe_formats.
184 * The first pipe format in the list that's supported is the one that's chosen.
186 static const struct format_mapping format_map
[] = {
187 /* Basic RGB, RGBA formats */
190 { PIPE_FORMAT_R10G10B10X2_UNORM
, PIPE_FORMAT_B10G10R10X2_UNORM
,
191 PIPE_FORMAT_R10G10B10A2_UNORM
, PIPE_FORMAT_B10G10R10A2_UNORM
,
192 DEFAULT_RGB_FORMATS
}
196 { PIPE_FORMAT_R10G10B10A2_UNORM
, PIPE_FORMAT_B10G10R10A2_UNORM
,
197 DEFAULT_RGBA_FORMATS
}
200 { 4, GL_RGBA
, GL_RGBA8
, 0 },
201 { PIPE_FORMAT_R8G8B8A8_UNORM
, DEFAULT_RGBA_FORMATS
}
205 { DEFAULT_RGBA_FORMATS
}
208 { 3, GL_RGB
, GL_RGB8
, 0 },
209 { PIPE_FORMAT_R8G8B8X8_UNORM
, DEFAULT_RGB_FORMATS
}
212 { GL_RGB12
, GL_RGB16
, 0 },
213 { PIPE_FORMAT_R16G16B16X16_UNORM
, PIPE_FORMAT_R16G16B16A16_UNORM
,
214 DEFAULT_RGB_FORMATS
}
217 { GL_RGBA12
, GL_RGBA16
, 0 },
218 { PIPE_FORMAT_R16G16B16A16_UNORM
, DEFAULT_RGBA_FORMATS
}
221 { GL_RGBA4
, GL_RGBA2
, 0 },
222 { PIPE_FORMAT_B4G4R4A4_UNORM
, PIPE_FORMAT_A4B4G4R4_UNORM
,
223 DEFAULT_RGBA_FORMATS
}
227 { PIPE_FORMAT_B5G5R5A1_UNORM
, PIPE_FORMAT_A1B5G5R5_UNORM
,
228 DEFAULT_RGBA_FORMATS
}
232 { PIPE_FORMAT_B2G3R3_UNORM
, PIPE_FORMAT_R3G3B2_UNORM
,
233 PIPE_FORMAT_B5G6R5_UNORM
, PIPE_FORMAT_B5G5R5A1_UNORM
,
234 DEFAULT_RGB_FORMATS
}
238 { PIPE_FORMAT_B4G4R4X4_UNORM
, PIPE_FORMAT_B4G4R4A4_UNORM
,
239 PIPE_FORMAT_A4B4G4R4_UNORM
,
240 DEFAULT_RGB_FORMATS
}
244 { PIPE_FORMAT_B5G5R5X1_UNORM
, PIPE_FORMAT_X1B5G5R5_UNORM
,
245 PIPE_FORMAT_B5G5R5A1_UNORM
, PIPE_FORMAT_A1B5G5R5_UNORM
,
246 DEFAULT_RGB_FORMATS
}
250 { PIPE_FORMAT_B5G6R5_UNORM
, DEFAULT_RGB_FORMATS
}
253 /* basic Alpha formats */
255 { GL_ALPHA12
, GL_ALPHA16
, 0 },
256 { PIPE_FORMAT_A16_UNORM
, PIPE_FORMAT_R16G16B16A16_UNORM
,
257 PIPE_FORMAT_A8_UNORM
, DEFAULT_RGBA_FORMATS
}
260 { GL_ALPHA
, GL_ALPHA4
, GL_ALPHA8
, GL_COMPRESSED_ALPHA
, 0 },
261 { PIPE_FORMAT_A8_UNORM
, DEFAULT_RGBA_FORMATS
}
264 /* basic Luminance formats */
266 { GL_LUMINANCE12
, GL_LUMINANCE16
, 0 },
267 { PIPE_FORMAT_L16_UNORM
, PIPE_FORMAT_R16G16B16A16_UNORM
,
268 PIPE_FORMAT_L8_UNORM
, DEFAULT_RGB_FORMATS
}
271 { 1, GL_LUMINANCE
, GL_LUMINANCE4
, GL_LUMINANCE8
, 0 },
272 { PIPE_FORMAT_L8_UNORM
, PIPE_FORMAT_L8A8_UNORM
, DEFAULT_RGB_FORMATS
}
275 /* basic Luminance/Alpha formats */
277 { GL_LUMINANCE12_ALPHA4
, GL_LUMINANCE12_ALPHA12
,
278 GL_LUMINANCE16_ALPHA16
, 0},
279 { PIPE_FORMAT_L16A16_UNORM
, PIPE_FORMAT_R16G16B16A16_UNORM
,
280 PIPE_FORMAT_L8A8_UNORM
, DEFAULT_RGBA_FORMATS
}
283 { 2, GL_LUMINANCE_ALPHA
, GL_LUMINANCE6_ALPHA2
, GL_LUMINANCE8_ALPHA8
, 0 },
284 { PIPE_FORMAT_L8A8_UNORM
, DEFAULT_RGBA_FORMATS
}
287 { GL_LUMINANCE4_ALPHA4
, 0 },
288 { PIPE_FORMAT_L4A4_UNORM
, PIPE_FORMAT_L8A8_UNORM
,
289 DEFAULT_RGBA_FORMATS
}
292 /* basic Intensity formats */
294 { GL_INTENSITY12
, GL_INTENSITY16
, 0 },
295 { PIPE_FORMAT_I16_UNORM
, PIPE_FORMAT_R16G16B16A16_UNORM
,
296 PIPE_FORMAT_I8_UNORM
, DEFAULT_RGBA_FORMATS
}
299 { GL_INTENSITY
, GL_INTENSITY4
, GL_INTENSITY8
,
300 GL_COMPRESSED_INTENSITY
, 0 },
301 { PIPE_FORMAT_I8_UNORM
, DEFAULT_RGBA_FORMATS
}
306 { GL_YCBCR_MESA
, 0 },
307 { PIPE_FORMAT_UYVY
, PIPE_FORMAT_YUYV
, 0 }
310 /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */
312 { GL_COMPRESSED_RGB
, 0 },
313 { PIPE_FORMAT_DXT1_RGB
, DEFAULT_RGB_FORMATS
}
316 { GL_COMPRESSED_RGBA
, 0 },
317 { PIPE_FORMAT_DXT5_RGBA
, DEFAULT_RGBA_FORMATS
}
320 { GL_RGB_S3TC
, GL_RGB4_S3TC
, GL_COMPRESSED_RGB_S3TC_DXT1_EXT
, 0 },
321 { PIPE_FORMAT_DXT1_RGB
, 0 }
324 { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
, 0 },
325 { PIPE_FORMAT_DXT1_RGBA
, 0 }
328 { GL_RGBA_S3TC
, GL_RGBA4_S3TC
, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
, 0 },
329 { PIPE_FORMAT_DXT3_RGBA
, 0 }
332 { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
, 0 },
333 { PIPE_FORMAT_DXT5_RGBA
, 0 }
337 { GL_COMPRESSED_RGB_FXT1_3DFX
, 0 },
338 { PIPE_FORMAT_FXT1_RGB
, 0 }
341 { GL_COMPRESSED_RGBA_FXT1_3DFX
, 0 },
342 { PIPE_FORMAT_FXT1_RGBA
, 0 }
347 { GL_DEPTH_COMPONENT16
, 0 },
348 { PIPE_FORMAT_Z16_UNORM
, DEFAULT_DEPTH_FORMATS
}
351 { GL_DEPTH_COMPONENT24
, 0 },
352 { PIPE_FORMAT_Z24X8_UNORM
, PIPE_FORMAT_X8Z24_UNORM
,
353 DEFAULT_DEPTH_FORMATS
}
356 { GL_DEPTH_COMPONENT32
, 0 },
357 { PIPE_FORMAT_Z32_UNORM
, DEFAULT_DEPTH_FORMATS
}
360 { GL_DEPTH_COMPONENT
, 0 },
361 { DEFAULT_DEPTH_FORMATS
}
364 { GL_DEPTH_COMPONENT32F
, 0 },
365 { PIPE_FORMAT_Z32_FLOAT
, 0 }
368 /* stencil formats */
370 { GL_STENCIL_INDEX
, GL_STENCIL_INDEX1_EXT
, GL_STENCIL_INDEX4_EXT
,
371 GL_STENCIL_INDEX8_EXT
, GL_STENCIL_INDEX16_EXT
, 0 },
373 PIPE_FORMAT_S8_UINT
, PIPE_FORMAT_Z24_UNORM_S8_UINT
,
374 PIPE_FORMAT_S8_UINT_Z24_UNORM
, 0
378 /* Depth / Stencil formats */
380 { GL_DEPTH_STENCIL_EXT
, GL_DEPTH24_STENCIL8_EXT
, 0 },
381 { PIPE_FORMAT_Z24_UNORM_S8_UINT
, PIPE_FORMAT_S8_UINT_Z24_UNORM
, 0 }
384 { GL_DEPTH32F_STENCIL8
, 0 },
385 { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT
, 0 }
390 { GL_SRGB_EXT
, GL_SRGB8_EXT
, 0 },
391 { PIPE_FORMAT_R8G8B8X8_SRGB
, PIPE_FORMAT_B8G8R8X8_SRGB
,
392 DEFAULT_SRGBA_FORMATS
}
395 { GL_SRGB_ALPHA_EXT
, GL_SRGB8_ALPHA8_EXT
, 0 },
396 { PIPE_FORMAT_R8G8B8A8_SRGB
, DEFAULT_SRGBA_FORMATS
}
399 { GL_COMPRESSED_SRGB_EXT
, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
, 0 },
400 { PIPE_FORMAT_DXT1_SRGB
, PIPE_FORMAT_R8G8B8X8_SRGB
,
401 PIPE_FORMAT_B8G8R8X8_SRGB
, DEFAULT_SRGBA_FORMATS
}
404 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
, 0 },
405 { PIPE_FORMAT_DXT1_SRGBA
, 0 }
408 { GL_COMPRESSED_SRGB_ALPHA_EXT
,
409 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
, 0 },
410 { PIPE_FORMAT_DXT3_SRGBA
, DEFAULT_SRGBA_FORMATS
}
413 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
, 0 },
414 { PIPE_FORMAT_DXT5_SRGBA
, 0 }
417 { GL_SLUMINANCE_ALPHA_EXT
, GL_SLUMINANCE8_ALPHA8_EXT
,
418 GL_COMPRESSED_SLUMINANCE_ALPHA_EXT
, 0 },
419 { PIPE_FORMAT_L8A8_SRGB
, DEFAULT_SRGBA_FORMATS
}
422 { GL_SLUMINANCE_EXT
, GL_SLUMINANCE8_EXT
, GL_COMPRESSED_SLUMINANCE_EXT
,
424 { PIPE_FORMAT_L8_SRGB
, DEFAULT_SRGBA_FORMATS
}
428 { PIPE_FORMAT_R8_SRGB
, 0 }
431 /* 16-bit float formats */
433 { GL_RGBA16F_ARB
, 0 },
434 { PIPE_FORMAT_R16G16B16A16_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
437 { GL_RGB16F_ARB
, 0 },
438 { PIPE_FORMAT_R16G16B16_FLOAT
, PIPE_FORMAT_R16G16B16X16_FLOAT
,
439 PIPE_FORMAT_R16G16B16A16_FLOAT
,
440 PIPE_FORMAT_R32G32B32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
443 { GL_LUMINANCE_ALPHA16F_ARB
, 0 },
444 { PIPE_FORMAT_L16A16_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
445 PIPE_FORMAT_L32A32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
448 { GL_ALPHA16F_ARB
, 0 },
449 { PIPE_FORMAT_A16_FLOAT
, PIPE_FORMAT_L16A16_FLOAT
,
450 PIPE_FORMAT_A32_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
451 PIPE_FORMAT_L32A32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
454 { GL_INTENSITY16F_ARB
, 0 },
455 { PIPE_FORMAT_I16_FLOAT
, PIPE_FORMAT_L16A16_FLOAT
,
456 PIPE_FORMAT_I32_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
457 PIPE_FORMAT_L32A32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
460 { GL_LUMINANCE16F_ARB
, 0 },
461 { PIPE_FORMAT_L16_FLOAT
, PIPE_FORMAT_L16A16_FLOAT
,
462 PIPE_FORMAT_L32_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
463 PIPE_FORMAT_L32A32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
467 { PIPE_FORMAT_R16_FLOAT
, PIPE_FORMAT_R16G16_FLOAT
,
468 PIPE_FORMAT_R32_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
469 PIPE_FORMAT_R32G32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
473 { PIPE_FORMAT_R16G16_FLOAT
, PIPE_FORMAT_R16G16B16A16_FLOAT
,
474 PIPE_FORMAT_R32G32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
477 /* 32-bit float formats */
479 { GL_RGBA32F_ARB
, 0 },
480 { PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
483 { GL_RGB32F_ARB
, 0 },
484 { PIPE_FORMAT_R32G32B32_FLOAT
, PIPE_FORMAT_R32G32B32X32_FLOAT
,
485 PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
488 { GL_LUMINANCE_ALPHA32F_ARB
, 0 },
489 { PIPE_FORMAT_L32A32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
492 { GL_ALPHA32F_ARB
, 0 },
493 { PIPE_FORMAT_A32_FLOAT
, PIPE_FORMAT_L32A32_FLOAT
,
494 PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
497 { GL_INTENSITY32F_ARB
, 0 },
498 { PIPE_FORMAT_I32_FLOAT
, PIPE_FORMAT_L32A32_FLOAT
,
499 PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
502 { GL_LUMINANCE32F_ARB
, 0 },
503 { PIPE_FORMAT_L32_FLOAT
, PIPE_FORMAT_L32A32_FLOAT
,
504 PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
508 { PIPE_FORMAT_R32_FLOAT
, PIPE_FORMAT_R32G32_FLOAT
,
509 PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
513 { PIPE_FORMAT_R32G32_FLOAT
, PIPE_FORMAT_R32G32B32A32_FLOAT
, 0 }
518 { GL_RED
, GL_R8
, 0 },
519 { PIPE_FORMAT_R8_UNORM
, PIPE_FORMAT_R8G8_UNORM
, DEFAULT_RGBA_FORMATS
}
522 { GL_RG
, GL_RG8
, 0 },
523 { PIPE_FORMAT_R8G8_UNORM
, DEFAULT_RGBA_FORMATS
}
527 { PIPE_FORMAT_R16_UNORM
, PIPE_FORMAT_R16G16_UNORM
,
528 DEFAULT_UNORM16_RGBA_FORMATS
}
532 { PIPE_FORMAT_R16G16_UNORM
, DEFAULT_UNORM16_RGBA_FORMATS
}
535 /* compressed R, RG formats */
537 { GL_COMPRESSED_RED
, GL_COMPRESSED_RED_RGTC1
, 0 },
538 { PIPE_FORMAT_RGTC1_UNORM
, PIPE_FORMAT_R8_UNORM
, DEFAULT_RGBA_FORMATS
}
541 { GL_COMPRESSED_SIGNED_RED_RGTC1
, 0 },
542 { PIPE_FORMAT_RGTC1_SNORM
, DEFAULT_SNORM8_RGBA_FORMATS
}
545 { GL_COMPRESSED_RG
, GL_COMPRESSED_RG_RGTC2
, 0 },
546 { PIPE_FORMAT_RGTC2_UNORM
, PIPE_FORMAT_R8G8_UNORM
, DEFAULT_RGBA_FORMATS
}
549 { GL_COMPRESSED_SIGNED_RG_RGTC2
, 0 },
550 { PIPE_FORMAT_RGTC2_SNORM
, DEFAULT_SNORM8_RGBA_FORMATS
}
553 { GL_COMPRESSED_LUMINANCE
, GL_COMPRESSED_LUMINANCE_LATC1_EXT
, 0 },
554 { PIPE_FORMAT_LATC1_UNORM
, PIPE_FORMAT_L8_UNORM
, DEFAULT_RGBA_FORMATS
}
557 { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT
, 0 },
558 { PIPE_FORMAT_LATC1_SNORM
, DEFAULT_SNORM8_RGBA_FORMATS
}
561 { GL_COMPRESSED_LUMINANCE_ALPHA
, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT
,
562 GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI
, 0 },
563 { PIPE_FORMAT_LATC2_UNORM
, PIPE_FORMAT_L8A8_UNORM
, DEFAULT_RGBA_FORMATS
}
566 { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT
, 0 },
567 { PIPE_FORMAT_LATC2_SNORM
, DEFAULT_SNORM8_RGBA_FORMATS
}
572 { GL_ETC1_RGB8_OES
, 0 },
573 { PIPE_FORMAT_ETC1_RGB8
, 0 }
578 { GL_COMPRESSED_RGB8_ETC2
, 0 },
579 { PIPE_FORMAT_ETC2_RGB8
, 0 }
582 { GL_COMPRESSED_SRGB8_ETC2
, 0 },
583 { PIPE_FORMAT_ETC2_SRGB8
, 0 }
586 { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
, 0 },
587 { PIPE_FORMAT_ETC2_RGB8A1
, 0 }
590 { GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
, 0 },
591 { PIPE_FORMAT_ETC2_SRGB8A1
, 0 }
594 { GL_COMPRESSED_RGBA8_ETC2_EAC
, 0 },
595 { PIPE_FORMAT_ETC2_RGBA8
, 0 }
598 { GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
, 0 },
599 { PIPE_FORMAT_ETC2_SRGBA8
, 0 }
602 { GL_COMPRESSED_R11_EAC
, 0 },
603 { PIPE_FORMAT_ETC2_R11_UNORM
, 0 }
606 { GL_COMPRESSED_SIGNED_R11_EAC
, 0 },
607 { PIPE_FORMAT_ETC2_R11_SNORM
, 0 }
610 { GL_COMPRESSED_RG11_EAC
, 0 },
611 { PIPE_FORMAT_ETC2_RG11_UNORM
, 0 }
614 { GL_COMPRESSED_SIGNED_RG11_EAC
, 0 },
615 { PIPE_FORMAT_ETC2_RG11_SNORM
, 0 }
620 { GL_COMPRESSED_RGBA_BPTC_UNORM
, 0 },
621 { PIPE_FORMAT_BPTC_RGBA_UNORM
, 0 },
624 { GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM
, 0 },
625 { PIPE_FORMAT_BPTC_SRGBA
, 0 },
628 { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT
, 0 },
629 { PIPE_FORMAT_BPTC_RGB_FLOAT
, 0 },
632 { GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT
, 0 },
633 { PIPE_FORMAT_BPTC_RGB_UFLOAT
, 0 },
638 { GL_COMPRESSED_RGBA_ASTC_4x4_KHR
, 0 },
639 { PIPE_FORMAT_ASTC_4x4
, 0},
642 { GL_COMPRESSED_RGBA_ASTC_5x4_KHR
, 0 },
643 { PIPE_FORMAT_ASTC_5x4
, 0},
646 { GL_COMPRESSED_RGBA_ASTC_5x5_KHR
, 0 },
647 { PIPE_FORMAT_ASTC_5x5
, 0},
650 { GL_COMPRESSED_RGBA_ASTC_6x5_KHR
, 0 },
651 { PIPE_FORMAT_ASTC_6x5
, 0},
654 { GL_COMPRESSED_RGBA_ASTC_6x6_KHR
, 0 },
655 { PIPE_FORMAT_ASTC_6x6
, 0},
658 { GL_COMPRESSED_RGBA_ASTC_8x5_KHR
, 0 },
659 { PIPE_FORMAT_ASTC_8x5
, 0},
662 { GL_COMPRESSED_RGBA_ASTC_8x6_KHR
, 0 },
663 { PIPE_FORMAT_ASTC_8x6
, 0},
666 { GL_COMPRESSED_RGBA_ASTC_8x8_KHR
, 0 },
667 { PIPE_FORMAT_ASTC_8x8
, 0},
670 { GL_COMPRESSED_RGBA_ASTC_10x5_KHR
, 0 },
671 { PIPE_FORMAT_ASTC_10x5
, 0},
674 { GL_COMPRESSED_RGBA_ASTC_10x6_KHR
, 0 },
675 { PIPE_FORMAT_ASTC_10x6
, 0},
678 { GL_COMPRESSED_RGBA_ASTC_10x8_KHR
, 0 },
679 { PIPE_FORMAT_ASTC_10x8
, 0},
682 { GL_COMPRESSED_RGBA_ASTC_10x10_KHR
, 0 },
683 { PIPE_FORMAT_ASTC_10x10
, 0},
686 { GL_COMPRESSED_RGBA_ASTC_12x10_KHR
, 0 },
687 { PIPE_FORMAT_ASTC_12x10
, 0},
690 { GL_COMPRESSED_RGBA_ASTC_12x12_KHR
, 0 },
691 { PIPE_FORMAT_ASTC_12x12
, 0},
695 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
, 0 },
696 { PIPE_FORMAT_ASTC_4x4_SRGB
, 0},
699 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
, 0 },
700 { PIPE_FORMAT_ASTC_5x4_SRGB
, 0},
703 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
, 0 },
704 { PIPE_FORMAT_ASTC_5x5_SRGB
, 0},
707 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
, 0 },
708 { PIPE_FORMAT_ASTC_6x5_SRGB
, 0},
711 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
, 0 },
712 { PIPE_FORMAT_ASTC_6x6_SRGB
, 0},
715 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
, 0 },
716 { PIPE_FORMAT_ASTC_8x5_SRGB
, 0},
719 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
, 0 },
720 { PIPE_FORMAT_ASTC_8x6_SRGB
, 0},
723 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
, 0 },
724 { PIPE_FORMAT_ASTC_8x8_SRGB
, 0},
727 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
, 0 },
728 { PIPE_FORMAT_ASTC_10x5_SRGB
, 0},
731 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
, 0 },
732 { PIPE_FORMAT_ASTC_10x6_SRGB
, 0},
735 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
, 0 },
736 { PIPE_FORMAT_ASTC_10x8_SRGB
, 0},
739 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
, 0 },
740 { PIPE_FORMAT_ASTC_10x10_SRGB
, 0},
743 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
, 0 },
744 { PIPE_FORMAT_ASTC_12x10_SRGB
, 0},
747 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
, 0 },
748 { PIPE_FORMAT_ASTC_12x12_SRGB
, 0},
751 /* signed/unsigned integer formats.
754 { GL_RGBA_INTEGER_EXT
,
757 { PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
760 { GL_RGB_INTEGER_EXT
,
763 GL_BLUE_INTEGER_EXT
, 0 },
764 { PIPE_FORMAT_R8G8B8_SINT
, PIPE_FORMAT_R8G8B8X8_SINT
,
765 PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
768 { GL_ALPHA_INTEGER_EXT
,
770 { PIPE_FORMAT_A8_SINT
, PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
773 { GL_ALPHA16I_EXT
, 0 },
774 { PIPE_FORMAT_A16_SINT
, PIPE_FORMAT_R16G16B16A16_SINT
, 0 }
777 { GL_ALPHA32I_EXT
, 0 },
778 { PIPE_FORMAT_A32_SINT
, PIPE_FORMAT_R32G32B32A32_SINT
, 0 }
781 { GL_ALPHA8UI_EXT
, 0 },
782 { PIPE_FORMAT_A8_UINT
, PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
785 { GL_ALPHA16UI_EXT
, 0 },
786 { PIPE_FORMAT_A16_UINT
, PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
789 { GL_ALPHA32UI_EXT
, 0 },
790 { PIPE_FORMAT_A32_UINT
, PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
793 { GL_INTENSITY8I_EXT
, 0 },
794 { PIPE_FORMAT_I8_SINT
, PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
797 { GL_INTENSITY16I_EXT
, 0 },
798 { PIPE_FORMAT_I16_SINT
, PIPE_FORMAT_R16G16B16A16_SINT
, 0 }
801 { GL_INTENSITY32I_EXT
, 0 },
802 { PIPE_FORMAT_I32_SINT
, PIPE_FORMAT_R32G32B32A32_SINT
, 0 }
805 { GL_INTENSITY8UI_EXT
, 0 },
806 { PIPE_FORMAT_I8_UINT
, PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
809 { GL_INTENSITY16UI_EXT
, 0 },
810 { PIPE_FORMAT_I16_UINT
, PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
813 { GL_INTENSITY32UI_EXT
, 0 },
814 { PIPE_FORMAT_I32_UINT
, PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
817 { GL_LUMINANCE8I_EXT
, 0 },
818 { PIPE_FORMAT_L8_SINT
, PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
821 { GL_LUMINANCE16I_EXT
, 0 },
822 { PIPE_FORMAT_L16_SINT
, PIPE_FORMAT_R16G16B16A16_SINT
, 0 }
825 { GL_LUMINANCE32I_EXT
, 0 },
826 { PIPE_FORMAT_L32_SINT
, PIPE_FORMAT_R32G32B32A32_SINT
, 0 }
829 { GL_LUMINANCE_INTEGER_EXT
,
830 GL_LUMINANCE8UI_EXT
, 0 },
831 { PIPE_FORMAT_L8_UINT
, PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
834 { GL_LUMINANCE16UI_EXT
, 0 },
835 { PIPE_FORMAT_L16_UINT
, PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
838 { GL_LUMINANCE32UI_EXT
, 0 },
839 { PIPE_FORMAT_L32_UINT
, PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
842 { GL_LUMINANCE_ALPHA_INTEGER_EXT
,
843 GL_LUMINANCE_ALPHA8I_EXT
, 0 },
844 { PIPE_FORMAT_L8A8_SINT
, PIPE_FORMAT_R8G8B8A8_SINT
, 0 }
847 { GL_LUMINANCE_ALPHA16I_EXT
, 0 },
848 { PIPE_FORMAT_L16A16_SINT
, PIPE_FORMAT_R16G16B16A16_SINT
, 0 }
851 { GL_LUMINANCE_ALPHA32I_EXT
, 0 },
852 { PIPE_FORMAT_L32A32_SINT
, PIPE_FORMAT_R32G32B32A32_SINT
, 0 }
855 { GL_LUMINANCE_ALPHA8UI_EXT
, 0 },
856 { PIPE_FORMAT_L8A8_UINT
, PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
859 { GL_LUMINANCE_ALPHA16UI_EXT
, 0 },
860 { PIPE_FORMAT_L16A16_UINT
, PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
863 { GL_LUMINANCE_ALPHA32UI_EXT
, 0 },
864 { PIPE_FORMAT_L32A32_UINT
, PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
867 { GL_RGB16I_EXT
, 0 },
868 { PIPE_FORMAT_R16G16B16_SINT
, PIPE_FORMAT_R16G16B16X16_SINT
,
869 PIPE_FORMAT_R16G16B16A16_SINT
, 0 },
872 { GL_RGBA16I_EXT
, 0 },
873 { PIPE_FORMAT_R16G16B16A16_SINT
, 0 },
876 { GL_RGB32I_EXT
, 0 },
877 { PIPE_FORMAT_R32G32B32_SINT
, PIPE_FORMAT_R32G32B32X32_SINT
,
878 PIPE_FORMAT_R32G32B32A32_SINT
, 0 },
881 { GL_RGBA32I_EXT
, 0 },
882 { PIPE_FORMAT_R32G32B32A32_SINT
, 0 }
885 { GL_RGBA8UI_EXT
, 0 },
886 { PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
889 { GL_RGB8UI_EXT
, 0 },
890 { PIPE_FORMAT_R8G8B8_UINT
, PIPE_FORMAT_R8G8B8X8_UINT
,
891 PIPE_FORMAT_R8G8B8A8_UINT
, 0 }
894 { GL_RGB16UI_EXT
, 0 },
895 { PIPE_FORMAT_R16G16B16_UINT
, PIPE_FORMAT_R16G16B16X16_UINT
,
896 PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
899 { GL_RGBA16UI_EXT
, 0 },
900 { PIPE_FORMAT_R16G16B16A16_UINT
, 0 }
903 { GL_RGB32UI_EXT
, 0},
904 { PIPE_FORMAT_R32G32B32_UINT
, PIPE_FORMAT_R32G32B32X32_UINT
,
905 PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
908 { GL_RGBA32UI_EXT
, 0},
909 { PIPE_FORMAT_R32G32B32A32_UINT
, 0 }
912 { GL_R8I
, GL_RED_INTEGER_EXT
, 0},
913 { PIPE_FORMAT_R8_SINT
, 0},
917 { PIPE_FORMAT_R16_SINT
, 0},
921 { PIPE_FORMAT_R32_SINT
, 0},
925 { PIPE_FORMAT_R8_UINT
, 0},
929 { PIPE_FORMAT_R16_UINT
, 0},
933 { PIPE_FORMAT_R32_UINT
, 0},
936 { GL_RG8I
, GL_GREEN_INTEGER_EXT
, 0},
937 { PIPE_FORMAT_R8G8_SINT
, 0},
941 { PIPE_FORMAT_R16G16_SINT
, 0},
945 { PIPE_FORMAT_R32G32_SINT
, 0},
949 { PIPE_FORMAT_R8G8_UINT
, 0},
953 { PIPE_FORMAT_R16G16_UINT
, 0},
957 { PIPE_FORMAT_R32G32_UINT
, 0},
959 /* signed normalized formats */
961 { GL_RED_SNORM
, GL_R8_SNORM
, 0 },
962 { PIPE_FORMAT_R8_SNORM
, PIPE_FORMAT_R8G8_SNORM
,
963 PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
967 { PIPE_FORMAT_R16_SNORM
,
968 PIPE_FORMAT_R16G16_SNORM
,
969 PIPE_FORMAT_R16G16B16A16_SNORM
,
970 PIPE_FORMAT_R8_SNORM
,
971 PIPE_FORMAT_R8G8_SNORM
,
972 PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
975 { GL_RG_SNORM
, GL_RG8_SNORM
, 0 },
976 { PIPE_FORMAT_R8G8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
979 { GL_RG16_SNORM
, 0 },
980 { PIPE_FORMAT_R16G16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
981 PIPE_FORMAT_R8G8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
984 { GL_RGB_SNORM
, GL_RGB8_SNORM
, 0 },
985 { PIPE_FORMAT_R8G8B8X8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
988 { GL_RGBA_SNORM
, GL_RGBA8_SNORM
, 0 },
989 { PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
992 { GL_RGB16_SNORM
, 0 },
993 { PIPE_FORMAT_R16G16B16X16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
994 PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
997 { GL_RGBA16_SNORM
, 0 },
998 { PIPE_FORMAT_R16G16B16A16_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1001 { GL_ALPHA_SNORM
, GL_ALPHA8_SNORM
, 0 },
1002 { PIPE_FORMAT_A8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1005 { GL_ALPHA16_SNORM
, 0 },
1006 { PIPE_FORMAT_A16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
1007 PIPE_FORMAT_A8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1010 { GL_LUMINANCE_SNORM
, GL_LUMINANCE8_SNORM
, 0 },
1011 { PIPE_FORMAT_L8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1014 { GL_LUMINANCE16_SNORM
, 0 },
1015 { PIPE_FORMAT_L16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
1016 PIPE_FORMAT_L8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1019 { GL_LUMINANCE_ALPHA_SNORM
, GL_LUMINANCE8_ALPHA8_SNORM
, 0 },
1020 { PIPE_FORMAT_L8A8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1023 { GL_LUMINANCE16_ALPHA16_SNORM
, 0 },
1024 { PIPE_FORMAT_L16A16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
1025 PIPE_FORMAT_L8A8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1028 { GL_INTENSITY_SNORM
, GL_INTENSITY8_SNORM
, 0 },
1029 { PIPE_FORMAT_I8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1032 { GL_INTENSITY16_SNORM
, 0 },
1033 { PIPE_FORMAT_I16_SNORM
, PIPE_FORMAT_R16G16B16A16_SNORM
,
1034 PIPE_FORMAT_I8_SNORM
, PIPE_FORMAT_R8G8B8A8_SNORM
, 0 }
1038 { PIPE_FORMAT_R9G9B9E5_FLOAT
, 0 }
1041 { GL_R11F_G11F_B10F
, 0 },
1042 { PIPE_FORMAT_R11G11B10_FLOAT
, 0 }
1045 { GL_RGB10_A2UI
, 0 },
1046 { PIPE_FORMAT_R10G10B10A2_UINT
, PIPE_FORMAT_B10G10R10A2_UINT
, 0 }
1052 * Return first supported format from the given list.
1053 * \param allow_dxt indicates whether it's OK to return a DXT format.
1055 static enum pipe_format
1056 find_supported_format(struct pipe_screen
*screen
,
1057 const enum pipe_format formats
[],
1058 enum pipe_texture_target target
,
1059 unsigned sample_count
,
1060 unsigned storage_sample_count
,
1065 for (i
= 0; formats
[i
]; i
++) {
1066 if (screen
->is_format_supported(screen
, formats
[i
], target
,
1067 sample_count
, storage_sample_count
,
1069 if (!allow_dxt
&& util_format_is_s3tc(formats
[i
])) {
1070 /* we can't return a dxt format, continue searching */
1077 return PIPE_FORMAT_NONE
;
1081 * Given an OpenGL internalFormat value for a texture or surface, return
1082 * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
1083 * This is called during glTexImage2D, for example.
1085 * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
1086 * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
1087 * we want render-to-texture ability.
1089 * \param internalFormat the user value passed to glTexImage2D
1090 * \param target one of PIPE_TEXTURE_x
1091 * \param bindings bitmask of PIPE_BIND_x flags.
1092 * \param allow_dxt indicates whether it's OK to return a DXT format. This
1093 * only matters when internalFormat names a generic or
1094 * specific compressed format. And that should only happen
1095 * when we're getting called from gl[Copy]TexImage().
1098 st_choose_format(struct st_context
*st
, GLenum internalFormat
,
1099 GLenum format
, GLenum type
,
1100 enum pipe_texture_target target
, unsigned sample_count
,
1101 unsigned storage_sample_count
,
1102 unsigned bindings
, bool swap_bytes
, bool allow_dxt
)
1104 struct pipe_screen
*screen
= st
->pipe
->screen
;
1107 enum pipe_format pf
;
1109 /* can't render to compressed formats at this time */
1110 if (_mesa_is_compressed_format(st
->ctx
, internalFormat
)
1111 && (bindings
& ~PIPE_BIND_SAMPLER_VIEW
)) {
1112 return PIPE_FORMAT_NONE
;
1115 /* If we have an unsized internalFormat, and the driver supports a format
1116 * that exactly matches format/type such that we can just memcpy, pick that
1117 * (unless the format wouldn't still be unorm, which is the expectation for
1120 if (_mesa_is_enum_format_unsized(internalFormat
) && format
!= 0 &&
1121 _mesa_is_type_unsigned(type
)) {
1122 pf
= st_choose_matching_format(st
, bindings
, format
, type
,
1125 if (pf
!= PIPE_FORMAT_NONE
&&
1126 screen
->is_format_supported(screen
, pf
, target
, sample_count
,
1127 storage_sample_count
, bindings
) &&
1128 _mesa_get_format_base_format(st_pipe_format_to_mesa_format(pf
)) ==
1134 /* For an unsized GL_RGB but a 2_10_10_10 type, try to pick one of the
1135 * 2_10_10_10 formats. This is important for
1136 * GL_EXT_texture_type_2_10_10_10_EXT support, which says that these
1137 * formats are not color-renderable. Mesa's check for making those
1138 * non-color-renderable is based on our chosen format being 2101010.
1140 if (type
== GL_UNSIGNED_INT_2_10_10_10_REV
) {
1141 if (internalFormat
== GL_RGB
)
1142 internalFormat
= GL_RGB10
;
1143 else if (internalFormat
== GL_RGBA
)
1144 internalFormat
= GL_RGB10_A2
;
1147 if (type
== GL_UNSIGNED_SHORT_5_5_5_1
) {
1148 if (internalFormat
== GL_RGB
)
1149 internalFormat
= GL_RGB5
;
1150 else if (internalFormat
== GL_RGBA
)
1151 internalFormat
= GL_RGB5_A1
;
1154 /* search table for internalFormat */
1155 for (i
= 0; i
< ARRAY_SIZE(format_map
); i
++) {
1156 const struct format_mapping
*mapping
= &format_map
[i
];
1157 for (j
= 0; mapping
->glFormats
[j
]; j
++) {
1158 if (mapping
->glFormats
[j
] == internalFormat
) {
1159 /* Found the desired internal format. Find first pipe format
1160 * which is supported by the driver.
1162 pf
= find_supported_format(screen
, mapping
->pipeFormats
,
1163 target
, sample_count
,
1164 storage_sample_count
, bindings
,
1171 _mesa_problem(NULL
, "unhandled format!\n");
1172 return PIPE_FORMAT_NONE
;
1176 debug_printf("%s(fmt=%s, type=%s, intFmt=%s) = %s\n",
1178 _mesa_enum_to_string(format
),
1179 _mesa_enum_to_string(type
),
1180 _mesa_enum_to_string(internalFormat
),
1181 util_format_name(pf
));
1188 * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
1191 st_choose_renderbuffer_format(struct st_context
*st
,
1192 GLenum internalFormat
, unsigned sample_count
,
1193 unsigned storage_sample_count
)
1196 if (_mesa_is_depth_or_stencil_format(internalFormat
))
1197 bindings
= PIPE_BIND_DEPTH_STENCIL
;
1199 bindings
= PIPE_BIND_RENDER_TARGET
;
1200 return st_choose_format(st
, internalFormat
, GL_NONE
, GL_NONE
,
1201 PIPE_TEXTURE_2D
, sample_count
,
1202 storage_sample_count
, bindings
,
1208 * Given an OpenGL user-requested format and type, and swapBytes state,
1209 * return the format which exactly matches those parameters, so that
1210 * a memcpy-based transfer can be done.
1212 * If no format is supported, return PIPE_FORMAT_NONE.
1215 st_choose_matching_format(struct st_context
*st
, unsigned bind
,
1216 GLenum format
, GLenum type
, GLboolean swapBytes
)
1218 struct pipe_screen
*screen
= st
->pipe
->screen
;
1220 if (swapBytes
&& !_mesa_swap_bytes_in_type_enum(&type
))
1221 return PIPE_FORMAT_NONE
;
1223 mesa_format mesa_format
= _mesa_format_from_format_and_type(format
, type
);
1224 if (_mesa_format_is_mesa_array_format(mesa_format
))
1225 mesa_format
= _mesa_format_from_array_format(mesa_format
);
1226 if (mesa_format
!= MESA_FORMAT_NONE
) {
1227 enum pipe_format format
= st_mesa_format_to_pipe_format(st
, mesa_format
);
1228 if (format
!= PIPE_FORMAT_NONE
&&
1229 screen
->is_format_supported(screen
, format
, PIPE_TEXTURE_2D
, 0, 0, bind
))
1233 return PIPE_FORMAT_NONE
;
1238 * Called via ctx->Driver.ChooseTextureFormat().
1241 st_ChooseTextureFormat(struct gl_context
*ctx
, GLenum target
,
1242 GLint internalFormat
,
1243 GLenum format
, GLenum type
)
1245 struct st_context
*st
= st_context(ctx
);
1246 enum pipe_format pFormat
;
1247 mesa_format mFormat
;
1249 bool is_renderbuffer
= false;
1250 enum pipe_texture_target pTarget
;
1252 if (target
== GL_RENDERBUFFER
) {
1253 pTarget
= PIPE_TEXTURE_2D
;
1254 is_renderbuffer
= true;
1256 pTarget
= gl_target_to_pipe(target
);
1259 if (target
== GL_TEXTURE_1D
|| target
== GL_TEXTURE_1D_ARRAY
) {
1260 /* We don't do compression for these texture targets because of
1261 * difficulty with sub-texture updates on non-block boundaries, etc.
1262 * So change the internal format request to an uncompressed format.
1265 _mesa_generic_compressed_format_to_uncompressed_format(internalFormat
);
1268 /* GL textures may wind up being render targets, but we don't know
1269 * that in advance. Specify potential render target flags now for formats
1270 * that we know should always be renderable.
1272 bindings
= PIPE_BIND_SAMPLER_VIEW
;
1273 if (_mesa_is_depth_or_stencil_format(internalFormat
))
1274 bindings
|= PIPE_BIND_DEPTH_STENCIL
;
1275 else if (is_renderbuffer
|| internalFormat
== 3 || internalFormat
== 4 ||
1276 internalFormat
== GL_RGB
|| internalFormat
== GL_RGBA
||
1277 internalFormat
== GL_RGBA2
||
1278 internalFormat
== GL_RGB4
|| internalFormat
== GL_RGBA4
||
1279 internalFormat
== GL_RGB8
|| internalFormat
== GL_RGBA8
||
1280 internalFormat
== GL_BGRA
||
1281 internalFormat
== GL_RGB16F
||
1282 internalFormat
== GL_RGBA16F
||
1283 internalFormat
== GL_RGB32F
||
1284 internalFormat
== GL_RGBA32F
)
1285 bindings
|= PIPE_BIND_RENDER_TARGET
;
1287 /* GLES allows the driver to choose any format which matches
1288 * the format+type combo, because GLES only supports unsized internal
1289 * formats and expects the driver to choose whatever suits it.
1291 if (_mesa_is_gles(ctx
)) {
1292 GLenum baseFormat
= _mesa_base_tex_format(ctx
, internalFormat
);
1293 GLenum basePackFormat
= _mesa_base_pack_format(format
);
1294 GLenum iformat
= internalFormat
;
1296 /* Treat GL_BGRA as GL_RGBA. */
1297 if (iformat
== GL_BGRA
)
1300 /* Check if the internalformat is unsized and compatible
1301 * with the "format".
1303 if (iformat
== baseFormat
&& iformat
== basePackFormat
) {
1304 pFormat
= st_choose_matching_format(st
, bindings
, format
, type
,
1305 ctx
->Unpack
.SwapBytes
);
1307 if (pFormat
!= PIPE_FORMAT_NONE
)
1308 return st_pipe_format_to_mesa_format(pFormat
);
1310 if (!is_renderbuffer
) {
1311 /* try choosing format again, this time without render
1314 pFormat
= st_choose_matching_format(st
, PIPE_BIND_SAMPLER_VIEW
,
1316 ctx
->Unpack
.SwapBytes
);
1317 if (pFormat
!= PIPE_FORMAT_NONE
)
1318 return st_pipe_format_to_mesa_format(pFormat
);
1323 pFormat
= st_choose_format(st
, internalFormat
, format
, type
,
1324 pTarget
, 0, 0, bindings
,
1325 ctx
->Unpack
.SwapBytes
, true);
1327 if (pFormat
== PIPE_FORMAT_NONE
&& !is_renderbuffer
) {
1328 /* try choosing format again, this time without render target bindings */
1329 pFormat
= st_choose_format(st
, internalFormat
, format
, type
,
1330 pTarget
, 0, 0, PIPE_BIND_SAMPLER_VIEW
,
1331 ctx
->Unpack
.SwapBytes
, true);
1334 if (pFormat
== PIPE_FORMAT_NONE
) {
1335 mFormat
= _mesa_glenum_to_compressed_format(internalFormat
);
1336 if (st_compressed_format_fallback(st
, mFormat
))
1339 /* no luck at all */
1340 return MESA_FORMAT_NONE
;
1343 mFormat
= st_pipe_format_to_mesa_format(pFormat
);
1347 debug_printf("%s(intFormat=%s, format=%s, type=%s) -> %s, %s\n",
1349 _mesa_enum_to_string(internalFormat
),
1350 _mesa_enum_to_string(format
),
1351 _mesa_enum_to_string(type
),
1352 util_format_name(pFormat
),
1353 _mesa_get_format_name(mFormat
));
1361 * Called via ctx->Driver.QueryInternalFormat().
1364 st_QuerySamplesForFormat(struct gl_context
*ctx
, GLenum target
,
1365 GLenum internalFormat
, int samples
[16])
1367 struct st_context
*st
= st_context(ctx
);
1368 enum pipe_format format
;
1369 unsigned i
, bind
, num_sample_counts
= 0;
1373 if (_mesa_is_depth_or_stencil_format(internalFormat
))
1374 bind
= PIPE_BIND_DEPTH_STENCIL
;
1376 bind
= PIPE_BIND_RENDER_TARGET
;
1378 /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
1381 if (!ctx
->Extensions
.EXT_sRGB
) {
1382 internalFormat
= _mesa_get_linear_internalformat(internalFormat
);
1385 /* Set sample counts in descending order. */
1386 for (i
= 16; i
> 1; i
--) {
1387 format
= st_choose_format(st
, internalFormat
, GL_NONE
, GL_NONE
,
1388 PIPE_TEXTURE_2D
, i
, i
, bind
,
1391 if (format
!= PIPE_FORMAT_NONE
) {
1392 samples
[num_sample_counts
++] = i
;
1396 if (!num_sample_counts
) {
1397 samples
[num_sample_counts
++] = 1;
1400 return num_sample_counts
;
1405 * ARB_internalformat_query2 driver hook.
1408 st_QueryInternalFormat(struct gl_context
*ctx
, GLenum target
,
1409 GLenum internalFormat
, GLenum pname
, GLint
*params
)
1411 struct st_context
*st
= st_context(ctx
);
1412 /* The API entry-point gives us a temporary params buffer that is non-NULL
1413 * and guaranteed to have at least 16 elements.
1415 assert(params
!= NULL
);
1419 st_QuerySamplesForFormat(ctx
, target
, internalFormat
, params
);
1422 case GL_NUM_SAMPLE_COUNTS
: {
1425 num_samples
= st_QuerySamplesForFormat(ctx
, target
, internalFormat
,
1427 params
[0] = (GLint
) num_samples
;
1430 case GL_INTERNALFORMAT_PREFERRED
: {
1431 params
[0] = GL_NONE
;
1433 /* We need to resolve an internal format that is compatible with
1434 * the passed internal format, and optimal to the driver. By now,
1435 * we just validate that the passed internal format is supported by
1436 * the driver, and if so return the same internal format, otherwise
1440 if (_mesa_is_depth_or_stencil_format(internalFormat
))
1441 bindings
= PIPE_BIND_DEPTH_STENCIL
;
1443 bindings
= PIPE_BIND_RENDER_TARGET
;
1444 enum pipe_format pformat
= st_choose_format(st
,
1448 PIPE_TEXTURE_2D
, 0, 0,
1452 params
[0] = internalFormat
;
1456 /* For the rest of the pnames, we call back the Mesa's default
1457 * function for drivers that don't implement ARB_internalformat_query2.
1459 _mesa_query_internal_format_default(ctx
, target
, internalFormat
, pname
,
1466 * This is used for translating texture border color and the clear
1467 * color. For example, the clear color is interpreted according to
1468 * the renderbuffer's base format. For example, if clearing a
1469 * GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
1470 * colorOut[2] = colorIn[0].
1471 * Similarly for texture border colors.
1474 st_translate_color(const union gl_color_union
*colorIn
,
1475 union pipe_color_union
*colorOut
,
1476 GLenum baseFormat
, GLboolean is_integer
)
1479 const int *in
= colorIn
->i
;
1480 int *out
= colorOut
->i
;
1482 switch (baseFormat
) {
1502 out
[0] = out
[1] = out
[2] = 0;
1506 out
[0] = out
[1] = out
[2] = in
[0];
1509 case GL_LUMINANCE_ALPHA
:
1510 out
[0] = out
[1] = out
[2] = in
[0];
1514 out
[0] = out
[1] = out
[2] = out
[3] = in
[0];
1521 const float *in
= colorIn
->f
;
1522 float *out
= colorOut
->f
;
1524 switch (baseFormat
) {
1544 out
[0] = out
[1] = out
[2] = 0.0F
;
1548 out
[0] = out
[1] = out
[2] = in
[0];
1551 case GL_LUMINANCE_ALPHA
:
1552 out
[0] = out
[1] = out
[2] = in
[0];
1555 /* Stencil border is tricky on some hw. Help drivers a little here. */
1556 case GL_STENCIL_INDEX
:
1558 out
[0] = out
[1] = out
[2] = out
[3] = in
[0];