projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: put gl_thread_state inside gl_context to remove pointer indirection
[mesa.git] / src / mesa / state_tracker / st_format.c
1 /**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc.
4 * Copyright (c) 2008-2010 VMware, Inc.
5 * All Rights Reserved.
6 *
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:
14 *
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
17 * of the Software.
18 *
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.
26 *
27 **************************************************************************/
28
29
30 /**
31 * Mesa / Gallium format conversion and format selection code.
32 * \author Brian Paul
33 */
34
35 #include "main/imports.h"
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"
47
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"
56
57
58 /**
59 * Translate Mesa format to Gallium format.
60 */
61 enum pipe_format
62 st_mesa_format_to_pipe_format(const struct st_context *st,
63 mesa_format mesaFormat)
64 {
65 struct pipe_screen *screen = st->pipe->screen;
66
67 /* The destination RGBA format mustn't be changed, because it's also
68 * a destination format of the unpack/decompression function.
69 */
70 if (mesaFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)
71 return PIPE_FORMAT_R8G8B8A8_UNORM;
72
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.
76 */
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);
82
83 switch (mesaFormat) {
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;
104 default:
105 unreachable("Unknown ETC2 format");
106 }
107 }
108
109 if (st_astc_format_fallback(st, mesaFormat)) {
110 if (_mesa_is_format_srgb(mesaFormat))
111 return PIPE_FORMAT_R8G8B8A8_SRGB;
112 else
113 return PIPE_FORMAT_R8G8B8A8_UNORM;
114 }
115
116 return mesaFormat;
117 }
118
119
120 /**
121 * Translate Gallium format to Mesa format.
122 */
123 mesa_format
124 st_pipe_format_to_mesa_format(enum pipe_format format)
125 {
126 mesa_format mf = format;
127 if (!_mesa_get_format_name(mf))
128 return MESA_FORMAT_NONE;
129 return mf;
130 }
131
132 /**
133 * Map GL texture formats to Gallium pipe formats.
134 */
135 struct format_mapping
136 {
137 GLenum glFormats[18]; /**< list of GLenum formats, 0-terminated */
138 enum pipe_format pipeFormats[14]; /**< list of pipe formats, 0-terminated */
139 };
140
141
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, \
147 0
148
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, \
155 DEFAULT_RGBA_FORMATS
156
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, \
162 0
163
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, \
170 0
171
172 #define DEFAULT_SNORM8_RGBA_FORMATS \
173 PIPE_FORMAT_R8G8B8A8_SNORM, \
174 0
175
176 #define DEFAULT_UNORM16_RGBA_FORMATS \
177 PIPE_FORMAT_R16G16B16A16_UNORM, \
178 DEFAULT_RGBA_FORMATS
179
180
181 /**
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.
185 */
186 static const struct format_mapping format_map[] = {
187 /* Basic RGB, RGBA formats */
188 {
189 { GL_RGB10, 0 },
190 { PIPE_FORMAT_R10G10B10X2_UNORM, PIPE_FORMAT_B10G10R10X2_UNORM,
191 PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
192 DEFAULT_RGB_FORMATS }
193 },
194 {
195 { GL_RGB10_A2, 0 },
196 { PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
197 DEFAULT_RGBA_FORMATS }
198 },
199 {
200 { 4, GL_RGBA, GL_RGBA8, 0 },
201 { PIPE_FORMAT_R8G8B8A8_UNORM, DEFAULT_RGBA_FORMATS }
202 },
203 {
204 { GL_BGRA, 0 },
205 { DEFAULT_RGBA_FORMATS }
206 },
207 {
208 { 3, GL_RGB, GL_RGB8, 0 },
209 { PIPE_FORMAT_R8G8B8X8_UNORM, DEFAULT_RGB_FORMATS }
210 },
211 {
212 { GL_RGB12, GL_RGB16, 0 },
213 { PIPE_FORMAT_R16G16B16X16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
214 DEFAULT_RGB_FORMATS }
215 },
216 {
217 { GL_RGBA12, GL_RGBA16, 0 },
218 { PIPE_FORMAT_R16G16B16A16_UNORM, DEFAULT_RGBA_FORMATS }
219 },
220 {
221 { GL_RGBA4, GL_RGBA2, 0 },
222 { PIPE_FORMAT_B4G4R4A4_UNORM, PIPE_FORMAT_A4B4G4R4_UNORM,
223 DEFAULT_RGBA_FORMATS }
224 },
225 {
226 { GL_RGB5_A1, 0 },
227 { PIPE_FORMAT_B5G5R5A1_UNORM, PIPE_FORMAT_A1B5G5R5_UNORM,
228 DEFAULT_RGBA_FORMATS }
229 },
230 {
231 { GL_R3_G3_B2, 0 },
232 { PIPE_FORMAT_B2G3R3_UNORM, PIPE_FORMAT_B5G6R5_UNORM,
233 PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGB_FORMATS }
234 },
235 {
236 { GL_RGB4 },
237 { PIPE_FORMAT_B4G4R4X4_UNORM, PIPE_FORMAT_B4G4R4A4_UNORM,
238 PIPE_FORMAT_A4B4G4R4_UNORM,
239 DEFAULT_RGB_FORMATS }
240 },
241 {
242 { GL_RGB5 },
243 { PIPE_FORMAT_B5G5R5X1_UNORM, PIPE_FORMAT_X1B5G5R5_UNORM,
244 PIPE_FORMAT_B5G5R5A1_UNORM, PIPE_FORMAT_A1B5G5R5_UNORM,
245 DEFAULT_RGB_FORMATS }
246 },
247 {
248 { GL_RGB565 },
249 { PIPE_FORMAT_B5G6R5_UNORM, DEFAULT_RGB_FORMATS }
250 },
251
252 /* basic Alpha formats */
253 {
254 { GL_ALPHA12, GL_ALPHA16, 0 },
255 { PIPE_FORMAT_A16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
256 PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
257 },
258 {
259 { GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_COMPRESSED_ALPHA, 0 },
260 { PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
261 },
262
263 /* basic Luminance formats */
264 {
265 { GL_LUMINANCE12, GL_LUMINANCE16, 0 },
266 { PIPE_FORMAT_L16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
267 PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
268 },
269 {
270 { 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 },
271 { PIPE_FORMAT_L8_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGB_FORMATS }
272 },
273
274 /* basic Luminance/Alpha formats */
275 {
276 { GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12,
277 GL_LUMINANCE16_ALPHA16, 0},
278 { PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
279 PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
280 },
281 {
282 { 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 },
283 { PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
284 },
285 {
286 { GL_LUMINANCE4_ALPHA4, 0 },
287 { PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM,
288 DEFAULT_RGBA_FORMATS }
289 },
290
291 /* basic Intensity formats */
292 {
293 { GL_INTENSITY12, GL_INTENSITY16, 0 },
294 { PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
295 PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
296 },
297 {
298 { GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8,
299 GL_COMPRESSED_INTENSITY, 0 },
300 { PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
301 },
302
303 /* YCbCr */
304 {
305 { GL_YCBCR_MESA, 0 },
306 { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 }
307 },
308
309 /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */
310 {
311 { GL_COMPRESSED_RGB, 0 },
312 { PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS }
313 },
314 {
315 { GL_COMPRESSED_RGBA, 0 },
316 { PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS }
317 },
318 {
319 { GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 },
320 { PIPE_FORMAT_DXT1_RGB, 0 }
321 },
322 {
323 { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 },
324 { PIPE_FORMAT_DXT1_RGBA, 0 }
325 },
326 {
327 { GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 },
328 { PIPE_FORMAT_DXT3_RGBA, 0 }
329 },
330 {
331 { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 },
332 { PIPE_FORMAT_DXT5_RGBA, 0 }
333 },
334
335 {
336 { GL_COMPRESSED_RGB_FXT1_3DFX, 0 },
337 { PIPE_FORMAT_FXT1_RGB, 0 }
338 },
339 {
340 { GL_COMPRESSED_RGBA_FXT1_3DFX, 0 },
341 { PIPE_FORMAT_FXT1_RGBA, 0 }
342 },
343
344 /* Depth formats */
345 {
346 { GL_DEPTH_COMPONENT16, 0 },
347 { PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS }
348 },
349 {
350 { GL_DEPTH_COMPONENT24, 0 },
351 { PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
352 DEFAULT_DEPTH_FORMATS }
353 },
354 {
355 { GL_DEPTH_COMPONENT32, 0 },
356 { PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS }
357 },
358 {
359 { GL_DEPTH_COMPONENT, 0 },
360 { DEFAULT_DEPTH_FORMATS }
361 },
362 {
363 { GL_DEPTH_COMPONENT32F, 0 },
364 { PIPE_FORMAT_Z32_FLOAT, 0 }
365 },
366
367 /* stencil formats */
368 {
369 { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
370 GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
371 {
372 PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
373 PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
374 }
375 },
376
377 /* Depth / Stencil formats */
378 {
379 { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
380 { PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
381 },
382 {
383 { GL_DEPTH32F_STENCIL8, 0 },
384 { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
385 },
386
387 /* sRGB formats */
388 {
389 { GL_SRGB_EXT, GL_SRGB8_EXT, 0 },
390 { PIPE_FORMAT_R8G8B8X8_SRGB, PIPE_FORMAT_B8G8R8X8_SRGB,
391 DEFAULT_SRGBA_FORMATS }
392 },
393 {
394 { GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 },
395 { PIPE_FORMAT_R8G8B8A8_SRGB, DEFAULT_SRGBA_FORMATS }
396 },
397 {
398 { GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 },
399 { PIPE_FORMAT_DXT1_SRGB, PIPE_FORMAT_R8G8B8X8_SRGB,
400 PIPE_FORMAT_B8G8R8X8_SRGB, DEFAULT_SRGBA_FORMATS }
401 },
402 {
403 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 },
404 { PIPE_FORMAT_DXT1_SRGBA, 0 }
405 },
406 {
407 { GL_COMPRESSED_SRGB_ALPHA_EXT,
408 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 },
409 { PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS }
410 },
411 {
412 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 },
413 { PIPE_FORMAT_DXT5_SRGBA, 0 }
414 },
415 {
416 { GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT,
417 GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 },
418 { PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS }
419 },
420 {
421 { GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, GL_COMPRESSED_SLUMINANCE_EXT,
422 0 },
423 { PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS }
424 },
425 {
426 { GL_SR8_EXT, 0 },
427 { PIPE_FORMAT_R8_SRGB, 0 }
428 },
429
430 /* 16-bit float formats */
431 {
432 { GL_RGBA16F_ARB, 0 },
433 { PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
434 },
435 {
436 { GL_RGB16F_ARB, 0 },
437 { PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16X16_FLOAT,
438 PIPE_FORMAT_R16G16B16A16_FLOAT,
439 PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
440 },
441 {
442 { GL_LUMINANCE_ALPHA16F_ARB, 0 },
443 { PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
444 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
445 },
446 {
447 { GL_ALPHA16F_ARB, 0 },
448 { PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
449 PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
450 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
451 },
452 {
453 { GL_INTENSITY16F_ARB, 0 },
454 { PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
455 PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
456 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
457 },
458 {
459 { GL_LUMINANCE16F_ARB, 0 },
460 { PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
461 PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
462 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
463 },
464 {
465 { GL_R16F, 0 },
466 { PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT,
467 PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
468 PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
469 },
470 {
471 { GL_RG16F, 0 },
472 { PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
473 PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
474 },
475
476 /* 32-bit float formats */
477 {
478 { GL_RGBA32F_ARB, 0 },
479 { PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
480 },
481 {
482 { GL_RGB32F_ARB, 0 },
483 { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32X32_FLOAT,
484 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
485 },
486 {
487 { GL_LUMINANCE_ALPHA32F_ARB, 0 },
488 { PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
489 },
490 {
491 { GL_ALPHA32F_ARB, 0 },
492 { PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
493 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
494 },
495 {
496 { GL_INTENSITY32F_ARB, 0 },
497 { PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
498 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
499 },
500 {
501 { GL_LUMINANCE32F_ARB, 0 },
502 { PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
503 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
504 },
505 {
506 { GL_R32F, 0 },
507 { PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT,
508 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
509 },
510 {
511 { GL_RG32F, 0 },
512 { PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
513 },
514
515 /* R, RG formats */
516 {
517 { GL_RED, GL_R8, 0 },
518 { PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
519 },
520 {
521 { GL_RG, GL_RG8, 0 },
522 { PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
523 },
524 {
525 { GL_R16, 0 },
526 { PIPE_FORMAT_R16_UNORM, PIPE_FORMAT_R16G16_UNORM,
527 DEFAULT_UNORM16_RGBA_FORMATS }
528 },
529 {
530 { GL_RG16, 0 },
531 { PIPE_FORMAT_R16G16_UNORM, DEFAULT_UNORM16_RGBA_FORMATS }
532 },
533
534 /* compressed R, RG formats */
535 {
536 { GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 },
537 { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, DEFAULT_RGBA_FORMATS }
538 },
539 {
540 { GL_COMPRESSED_SIGNED_RED_RGTC1, 0 },
541 { PIPE_FORMAT_RGTC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
542 },
543 {
544 { GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 },
545 { PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
546 },
547 {
548 { GL_COMPRESSED_SIGNED_RG_RGTC2, 0 },
549 { PIPE_FORMAT_RGTC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
550 },
551 {
552 { GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 },
553 { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGBA_FORMATS }
554 },
555 {
556 { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 },
557 { PIPE_FORMAT_LATC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
558 },
559 {
560 { GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
561 GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 },
562 { PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
563 },
564 {
565 { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 },
566 { PIPE_FORMAT_LATC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
567 },
568
569 /* ETC1 */
570 {
571 { GL_ETC1_RGB8_OES, 0 },
572 { PIPE_FORMAT_ETC1_RGB8, 0 }
573 },
574
575 /* ETC2 */
576 {
577 { GL_COMPRESSED_RGB8_ETC2, 0 },
578 { PIPE_FORMAT_ETC2_RGB8, 0 }
579 },
580 {
581 { GL_COMPRESSED_SRGB8_ETC2, 0 },
582 { PIPE_FORMAT_ETC2_SRGB8, 0 }
583 },
584 {
585 { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
586 { PIPE_FORMAT_ETC2_RGB8A1, 0 }
587 },
588 {
589 { GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
590 { PIPE_FORMAT_ETC2_SRGB8A1, 0 }
591 },
592 {
593 { GL_COMPRESSED_RGBA8_ETC2_EAC, 0 },
594 { PIPE_FORMAT_ETC2_RGBA8, 0 }
595 },
596 {
597 { GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0 },
598 { PIPE_FORMAT_ETC2_SRGBA8, 0 }
599 },
600 {
601 { GL_COMPRESSED_R11_EAC, 0 },
602 { PIPE_FORMAT_ETC2_R11_UNORM, 0 }
603 },
604 {
605 { GL_COMPRESSED_SIGNED_R11_EAC, 0 },
606 { PIPE_FORMAT_ETC2_R11_SNORM, 0 }
607 },
608 {
609 { GL_COMPRESSED_RG11_EAC, 0 },
610 { PIPE_FORMAT_ETC2_RG11_UNORM, 0 }
611 },
612 {
613 { GL_COMPRESSED_SIGNED_RG11_EAC, 0 },
614 { PIPE_FORMAT_ETC2_RG11_SNORM, 0 }
615 },
616
617 /* BPTC */
618 {
619 { GL_COMPRESSED_RGBA_BPTC_UNORM, 0 },
620 { PIPE_FORMAT_BPTC_RGBA_UNORM, 0 },
621 },
622 {
623 { GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, 0 },
624 { PIPE_FORMAT_BPTC_SRGBA, 0 },
625 },
626 {
627 { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, 0 },
628 { PIPE_FORMAT_BPTC_RGB_FLOAT, 0 },
629 },
630 {
631 { GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, 0 },
632 { PIPE_FORMAT_BPTC_RGB_UFLOAT, 0 },
633 },
634
635 /* ASTC */
636 {
637 { GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0 },
638 { PIPE_FORMAT_ASTC_4x4, 0},
639 },
640 {
641 { GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0 },
642 { PIPE_FORMAT_ASTC_5x4, 0},
643 },
644 {
645 { GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0 },
646 { PIPE_FORMAT_ASTC_5x5, 0},
647 },
648 {
649 { GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0 },
650 { PIPE_FORMAT_ASTC_6x5, 0},
651 },
652 {
653 { GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0 },
654 { PIPE_FORMAT_ASTC_6x6, 0},
655 },
656 {
657 { GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0 },
658 { PIPE_FORMAT_ASTC_8x5, 0},
659 },
660 {
661 { GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0 },
662 { PIPE_FORMAT_ASTC_8x6, 0},
663 },
664 {
665 { GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0 },
666 { PIPE_FORMAT_ASTC_8x8, 0},
667 },
668 {
669 { GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0 },
670 { PIPE_FORMAT_ASTC_10x5, 0},
671 },
672 {
673 { GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0 },
674 { PIPE_FORMAT_ASTC_10x6, 0},
675 },
676 {
677 { GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0 },
678 { PIPE_FORMAT_ASTC_10x8, 0},
679 },
680 {
681 { GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0 },
682 { PIPE_FORMAT_ASTC_10x10, 0},
683 },
684 {
685 { GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0 },
686 { PIPE_FORMAT_ASTC_12x10, 0},
687 },
688 {
689 { GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0 },
690 { PIPE_FORMAT_ASTC_12x12, 0},
691 },
692
693 {
694 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0 },
695 { PIPE_FORMAT_ASTC_4x4_SRGB, 0},
696 },
697 {
698 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0 },
699 { PIPE_FORMAT_ASTC_5x4_SRGB, 0},
700 },
701 {
702 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0 },
703 { PIPE_FORMAT_ASTC_5x5_SRGB, 0},
704 },
705 {
706 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0 },
707 { PIPE_FORMAT_ASTC_6x5_SRGB, 0},
708 },
709 {
710 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0 },
711 { PIPE_FORMAT_ASTC_6x6_SRGB, 0},
712 },
713 {
714 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0 },
715 { PIPE_FORMAT_ASTC_8x5_SRGB, 0},
716 },
717 {
718 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0 },
719 { PIPE_FORMAT_ASTC_8x6_SRGB, 0},
720 },
721 {
722 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0 },
723 { PIPE_FORMAT_ASTC_8x8_SRGB, 0},
724 },
725 {
726 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0 },
727 { PIPE_FORMAT_ASTC_10x5_SRGB, 0},
728 },
729 {
730 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0 },
731 { PIPE_FORMAT_ASTC_10x6_SRGB, 0},
732 },
733 {
734 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0 },
735 { PIPE_FORMAT_ASTC_10x8_SRGB, 0},
736 },
737 {
738 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0 },
739 { PIPE_FORMAT_ASTC_10x10_SRGB, 0},
740 },
741 {
742 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0 },
743 { PIPE_FORMAT_ASTC_12x10_SRGB, 0},
744 },
745 {
746 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0 },
747 { PIPE_FORMAT_ASTC_12x12_SRGB, 0},
748 },
749
750 /* signed/unsigned integer formats.
751 */
752 {
753 { GL_RGBA_INTEGER_EXT,
754 GL_BGRA_INTEGER_EXT,
755 GL_RGBA8I_EXT, 0 },
756 { PIPE_FORMAT_R8G8B8A8_SINT, 0 }
757 },
758 {
759 { GL_RGB_INTEGER_EXT,
760 GL_BGR_INTEGER_EXT,
761 GL_RGB8I_EXT,
762 GL_BLUE_INTEGER_EXT, 0 },
763 { PIPE_FORMAT_R8G8B8_SINT, PIPE_FORMAT_R8G8B8X8_SINT,
764 PIPE_FORMAT_R8G8B8A8_SINT, 0 }
765 },
766 {
767 { GL_ALPHA_INTEGER_EXT,
768 GL_ALPHA8I_EXT, 0 },
769 { PIPE_FORMAT_A8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
770 },
771 {
772 { GL_ALPHA16I_EXT, 0 },
773 { PIPE_FORMAT_A16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
774 },
775 {
776 { GL_ALPHA32I_EXT, 0 },
777 { PIPE_FORMAT_A32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
778 },
779 {
780 { GL_ALPHA8UI_EXT, 0 },
781 { PIPE_FORMAT_A8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
782 },
783 {
784 { GL_ALPHA16UI_EXT, 0 },
785 { PIPE_FORMAT_A16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
786 },
787 {
788 { GL_ALPHA32UI_EXT, 0 },
789 { PIPE_FORMAT_A32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
790 },
791 {
792 { GL_INTENSITY8I_EXT, 0 },
793 { PIPE_FORMAT_I8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
794 },
795 {
796 { GL_INTENSITY16I_EXT, 0 },
797 { PIPE_FORMAT_I16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
798 },
799 {
800 { GL_INTENSITY32I_EXT, 0 },
801 { PIPE_FORMAT_I32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
802 },
803 {
804 { GL_INTENSITY8UI_EXT, 0 },
805 { PIPE_FORMAT_I8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
806 },
807 {
808 { GL_INTENSITY16UI_EXT, 0 },
809 { PIPE_FORMAT_I16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
810 },
811 {
812 { GL_INTENSITY32UI_EXT, 0 },
813 { PIPE_FORMAT_I32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
814 },
815 {
816 { GL_LUMINANCE8I_EXT, 0 },
817 { PIPE_FORMAT_L8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
818 },
819 {
820 { GL_LUMINANCE16I_EXT, 0 },
821 { PIPE_FORMAT_L16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
822 },
823 {
824 { GL_LUMINANCE32I_EXT, 0 },
825 { PIPE_FORMAT_L32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
826 },
827 {
828 { GL_LUMINANCE_INTEGER_EXT,
829 GL_LUMINANCE8UI_EXT, 0 },
830 { PIPE_FORMAT_L8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
831 },
832 {
833 { GL_LUMINANCE16UI_EXT, 0 },
834 { PIPE_FORMAT_L16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
835 },
836 {
837 { GL_LUMINANCE32UI_EXT, 0 },
838 { PIPE_FORMAT_L32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
839 },
840 {
841 { GL_LUMINANCE_ALPHA_INTEGER_EXT,
842 GL_LUMINANCE_ALPHA8I_EXT, 0 },
843 { PIPE_FORMAT_L8A8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
844 },
845 {
846 { GL_LUMINANCE_ALPHA16I_EXT, 0 },
847 { PIPE_FORMAT_L16A16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
848 },
849 {
850 { GL_LUMINANCE_ALPHA32I_EXT, 0 },
851 { PIPE_FORMAT_L32A32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
852 },
853 {
854 { GL_LUMINANCE_ALPHA8UI_EXT, 0 },
855 { PIPE_FORMAT_L8A8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
856 },
857 {
858 { GL_LUMINANCE_ALPHA16UI_EXT, 0 },
859 { PIPE_FORMAT_L16A16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
860 },
861 {
862 { GL_LUMINANCE_ALPHA32UI_EXT, 0 },
863 { PIPE_FORMAT_L32A32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
864 },
865 {
866 { GL_RGB16I_EXT, 0 },
867 { PIPE_FORMAT_R16G16B16_SINT, PIPE_FORMAT_R16G16B16X16_SINT,
868 PIPE_FORMAT_R16G16B16A16_SINT, 0 },
869 },
870 {
871 { GL_RGBA16I_EXT, 0 },
872 { PIPE_FORMAT_R16G16B16A16_SINT, 0 },
873 },
874 {
875 { GL_RGB32I_EXT, 0 },
876 { PIPE_FORMAT_R32G32B32_SINT, PIPE_FORMAT_R32G32B32X32_SINT,
877 PIPE_FORMAT_R32G32B32A32_SINT, 0 },
878 },
879 {
880 { GL_RGBA32I_EXT, 0 },
881 { PIPE_FORMAT_R32G32B32A32_SINT, 0 }
882 },
883 {
884 { GL_RGBA8UI_EXT, 0 },
885 { PIPE_FORMAT_R8G8B8A8_UINT, 0 }
886 },
887 {
888 { GL_RGB8UI_EXT, 0 },
889 { PIPE_FORMAT_R8G8B8_UINT, PIPE_FORMAT_R8G8B8X8_UINT,
890 PIPE_FORMAT_R8G8B8A8_UINT, 0 }
891 },
892 {
893 { GL_RGB16UI_EXT, 0 },
894 { PIPE_FORMAT_R16G16B16_UINT, PIPE_FORMAT_R16G16B16X16_UINT,
895 PIPE_FORMAT_R16G16B16A16_UINT, 0 }
896 },
897 {
898 { GL_RGBA16UI_EXT, 0 },
899 { PIPE_FORMAT_R16G16B16A16_UINT, 0 }
900 },
901 {
902 { GL_RGB32UI_EXT, 0},
903 { PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32X32_UINT,
904 PIPE_FORMAT_R32G32B32A32_UINT, 0 }
905 },
906 {
907 { GL_RGBA32UI_EXT, 0},
908 { PIPE_FORMAT_R32G32B32A32_UINT, 0 }
909 },
910 {
911 { GL_R8I, GL_RED_INTEGER_EXT, 0},
912 { PIPE_FORMAT_R8_SINT, 0},
913 },
914 {
915 { GL_R16I, 0},
916 { PIPE_FORMAT_R16_SINT, 0},
917 },
918 {
919 { GL_R32I, 0},
920 { PIPE_FORMAT_R32_SINT, 0},
921 },
922 {
923 { GL_R8UI, 0},
924 { PIPE_FORMAT_R8_UINT, 0},
925 },
926 {
927 { GL_R16UI, 0},
928 { PIPE_FORMAT_R16_UINT, 0},
929 },
930 {
931 { GL_R32UI, 0},
932 { PIPE_FORMAT_R32_UINT, 0},
933 },
934 {
935 { GL_RG8I, GL_GREEN_INTEGER_EXT, 0},
936 { PIPE_FORMAT_R8G8_SINT, 0},
937 },
938 {
939 { GL_RG16I, 0},
940 { PIPE_FORMAT_R16G16_SINT, 0},
941 },
942 {
943 { GL_RG32I, 0},
944 { PIPE_FORMAT_R32G32_SINT, 0},
945 },
946 {
947 { GL_RG8UI, 0},
948 { PIPE_FORMAT_R8G8_UINT, 0},
949 },
950 {
951 { GL_RG16UI, 0},
952 { PIPE_FORMAT_R16G16_UINT, 0},
953 },
954 {
955 { GL_RG32UI, 0},
956 { PIPE_FORMAT_R32G32_UINT, 0},
957 },
958 /* signed normalized formats */
959 {
960 { GL_RED_SNORM, GL_R8_SNORM, 0 },
961 { PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM,
962 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
963 },
964 {
965 { GL_R16_SNORM, 0 },
966 { PIPE_FORMAT_R16_SNORM,
967 PIPE_FORMAT_R16G16_SNORM,
968 PIPE_FORMAT_R16G16B16A16_SNORM,
969 PIPE_FORMAT_R8_SNORM,
970 PIPE_FORMAT_R8G8_SNORM,
971 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
972 },
973 {
974 { GL_RG_SNORM, GL_RG8_SNORM, 0 },
975 { PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
976 },
977 {
978 { GL_RG16_SNORM, 0 },
979 { PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
980 PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
981 },
982 {
983 { GL_RGB_SNORM, GL_RGB8_SNORM, 0 },
984 { PIPE_FORMAT_R8G8B8X8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
985 },
986 {
987 { GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 },
988 { PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
989 },
990 {
991 { GL_RGB16_SNORM, 0 },
992 { PIPE_FORMAT_R16G16B16X16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
993 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
994 },
995 {
996 { GL_RGBA16_SNORM, 0 },
997 { PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
998 },
999 {
1000 { GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 },
1001 { PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1002 },
1003 {
1004 { GL_ALPHA16_SNORM, 0 },
1005 { PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1006 PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1007 },
1008 {
1009 { GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 },
1010 { PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1011 },
1012 {
1013 { GL_LUMINANCE16_SNORM, 0 },
1014 { PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1015 PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1016 },
1017 {
1018 { GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 },
1019 { PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1020 },
1021 {
1022 { GL_LUMINANCE16_ALPHA16_SNORM, 0 },
1023 { PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1024 PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1025 },
1026 {
1027 { GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 },
1028 { PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1029 },
1030 {
1031 { GL_INTENSITY16_SNORM, 0 },
1032 { PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1033 PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1034 },
1035 {
1036 { GL_RGB9_E5, 0 },
1037 { PIPE_FORMAT_R9G9B9E5_FLOAT, 0 }
1038 },
1039 {
1040 { GL_R11F_G11F_B10F, 0 },
1041 { PIPE_FORMAT_R11G11B10_FLOAT, 0 }
1042 },
1043 {
1044 { GL_RGB10_A2UI, 0 },
1045 { PIPE_FORMAT_R10G10B10A2_UINT, PIPE_FORMAT_B10G10R10A2_UINT, 0 }
1046 },
1047 };
1048
1049
1050 /**
1051 * Return first supported format from the given list.
1052 * \param allow_dxt indicates whether it's OK to return a DXT format.
1053 */
1054 static enum pipe_format
1055 find_supported_format(struct pipe_screen *screen,
1056 const enum pipe_format formats[],
1057 enum pipe_texture_target target,
1058 unsigned sample_count,
1059 unsigned storage_sample_count,
1060 unsigned bindings,
1061 boolean allow_dxt)
1062 {
1063 uint i;
1064 for (i = 0; formats[i]; i++) {
1065 if (screen->is_format_supported(screen, formats[i], target,
1066 sample_count, storage_sample_count,
1067 bindings)) {
1068 if (!allow_dxt && util_format_is_s3tc(formats[i])) {
1069 /* we can't return a dxt format, continue searching */
1070 continue;
1071 }
1072
1073 return formats[i];
1074 }
1075 }
1076 return PIPE_FORMAT_NONE;
1077 }
1078
1079 /**
1080 * Given an OpenGL internalFormat value for a texture or surface, return
1081 * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
1082 * This is called during glTexImage2D, for example.
1083 *
1084 * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
1085 * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
1086 * we want render-to-texture ability.
1087 *
1088 * \param internalFormat the user value passed to glTexImage2D
1089 * \param target one of PIPE_TEXTURE_x
1090 * \param bindings bitmask of PIPE_BIND_x flags.
1091 * \param allow_dxt indicates whether it's OK to return a DXT format. This
1092 * only matters when internalFormat names a generic or
1093 * specific compressed format. And that should only happen
1094 * when we're getting called from gl[Copy]TexImage().
1095 */
1096 enum pipe_format
1097 st_choose_format(struct st_context *st, GLenum internalFormat,
1098 GLenum format, GLenum type,
1099 enum pipe_texture_target target, unsigned sample_count,
1100 unsigned storage_sample_count,
1101 unsigned bindings, bool swap_bytes, bool allow_dxt)
1102 {
1103 struct pipe_screen *screen = st->pipe->screen;
1104 unsigned i;
1105 int j;
1106 enum pipe_format pf;
1107
1108 /* can't render to compressed formats at this time */
1109 if (_mesa_is_compressed_format(st->ctx, internalFormat)
1110 && (bindings & ~PIPE_BIND_SAMPLER_VIEW)) {
1111 return PIPE_FORMAT_NONE;
1112 }
1113
1114 /* If we have an unsized internalFormat, and the driver supports a format
1115 * that exactly matches format/type such that we can just memcpy, pick that
1116 * (unless the format wouldn't still be unorm, which is the expectation for
1117 * unsized formats).
1118 */
1119 if (_mesa_is_enum_format_unsized(internalFormat) && format != 0 &&
1120 _mesa_is_type_unsigned(type)) {
1121 pf = st_choose_matching_format(st, bindings, format, type,
1122 swap_bytes);
1123
1124 if (pf != PIPE_FORMAT_NONE &&
1125 screen->is_format_supported(screen, pf, target, sample_count,
1126 storage_sample_count, bindings) &&
1127 _mesa_get_format_base_format(st_pipe_format_to_mesa_format(pf)) ==
1128 internalFormat) {
1129 goto success;
1130 }
1131 }
1132
1133 /* For an unsized GL_RGB but a 2_10_10_10 type, try to pick one of the
1134 * 2_10_10_10 formats. This is important for
1135 * GL_EXT_texture_type_2_10_10_10_EXT support, which says that these
1136 * formats are not color-renderable. Mesa's check for making those
1137 * non-color-renderable is based on our chosen format being 2101010.
1138 */
1139 if (type == GL_UNSIGNED_INT_2_10_10_10_REV) {
1140 if (internalFormat == GL_RGB)
1141 internalFormat = GL_RGB10;
1142 else if (internalFormat == GL_RGBA)
1143 internalFormat = GL_RGB10_A2;
1144 }
1145
1146 if (type == GL_UNSIGNED_SHORT_5_5_5_1) {
1147 if (internalFormat == GL_RGB)
1148 internalFormat = GL_RGB5;
1149 else if (internalFormat == GL_RGBA)
1150 internalFormat = GL_RGB5_A1;
1151 }
1152
1153 /* search table for internalFormat */
1154 for (i = 0; i < ARRAY_SIZE(format_map); i++) {
1155 const struct format_mapping *mapping = &format_map[i];
1156 for (j = 0; mapping->glFormats[j]; j++) {
1157 if (mapping->glFormats[j] == internalFormat) {
1158 /* Found the desired internal format. Find first pipe format
1159 * which is supported by the driver.
1160 */
1161 pf = find_supported_format(screen, mapping->pipeFormats,
1162 target, sample_count,
1163 storage_sample_count, bindings,
1164 allow_dxt);
1165 goto success;
1166 }
1167 }
1168 }
1169
1170 _mesa_problem(NULL, "unhandled format!\n");
1171 return PIPE_FORMAT_NONE;
1172
1173 success:
1174 if (0) {
1175 debug_printf("%s(fmt=%s, type=%s, intFmt=%s) = %s\n",
1176 __FUNCTION__,
1177 _mesa_enum_to_string(format),
1178 _mesa_enum_to_string(type),
1179 _mesa_enum_to_string(internalFormat),
1180 util_format_name(pf));
1181 }
1182 return pf;
1183 }
1184
1185
1186 /**
1187 * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
1188 */
1189 enum pipe_format
1190 st_choose_renderbuffer_format(struct st_context *st,
1191 GLenum internalFormat, unsigned sample_count,
1192 unsigned storage_sample_count)
1193 {
1194 unsigned bindings;
1195 if (_mesa_is_depth_or_stencil_format(internalFormat))
1196 bindings = PIPE_BIND_DEPTH_STENCIL;
1197 else
1198 bindings = PIPE_BIND_RENDER_TARGET;
1199 return st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
1200 PIPE_TEXTURE_2D, sample_count,
1201 storage_sample_count, bindings,
1202 false, false);
1203 }
1204
1205
1206 /**
1207 * Given an OpenGL user-requested format and type, and swapBytes state,
1208 * return the format which exactly matches those parameters, so that
1209 * a memcpy-based transfer can be done.
1210 *
1211 * If no format is supported, return PIPE_FORMAT_NONE.
1212 */
1213 enum pipe_format
1214 st_choose_matching_format(struct st_context *st, unsigned bind,
1215 GLenum format, GLenum type, GLboolean swapBytes)
1216 {
1217 struct pipe_screen *screen = st->pipe->screen;
1218
1219 if (swapBytes && !_mesa_swap_bytes_in_type_enum(&type))
1220 return PIPE_FORMAT_NONE;
1221
1222 mesa_format mesa_format = _mesa_format_from_format_and_type(format, type);
1223 if (_mesa_format_is_mesa_array_format(mesa_format))
1224 mesa_format = _mesa_format_from_array_format(mesa_format);
1225 if (mesa_format != MESA_FORMAT_NONE) {
1226 enum pipe_format format = st_mesa_format_to_pipe_format(st, mesa_format);
1227 if (format != PIPE_FORMAT_NONE &&
1228 screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, 0, bind))
1229 return format;
1230 }
1231
1232 return PIPE_FORMAT_NONE;
1233 }
1234
1235
1236 /**
1237 * Called via ctx->Driver.ChooseTextureFormat().
1238 */
1239 mesa_format
1240 st_ChooseTextureFormat(struct gl_context *ctx, GLenum target,
1241 GLint internalFormat,
1242 GLenum format, GLenum type)
1243 {
1244 struct st_context *st = st_context(ctx);
1245 enum pipe_format pFormat;
1246 mesa_format mFormat;
1247 unsigned bindings;
1248 bool is_renderbuffer = false;
1249 enum pipe_texture_target pTarget;
1250
1251 if (target == GL_RENDERBUFFER) {
1252 pTarget = PIPE_TEXTURE_2D;
1253 is_renderbuffer = true;
1254 } else {
1255 pTarget = gl_target_to_pipe(target);
1256 }
1257
1258 if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) {
1259 /* We don't do compression for these texture targets because of
1260 * difficulty with sub-texture updates on non-block boundaries, etc.
1261 * So change the internal format request to an uncompressed format.
1262 */
1263 internalFormat =
1264 _mesa_generic_compressed_format_to_uncompressed_format(internalFormat);
1265 }
1266
1267 /* GL textures may wind up being render targets, but we don't know
1268 * that in advance. Specify potential render target flags now for formats
1269 * that we know should always be renderable.
1270 */
1271 bindings = PIPE_BIND_SAMPLER_VIEW;
1272 if (_mesa_is_depth_or_stencil_format(internalFormat))
1273 bindings |= PIPE_BIND_DEPTH_STENCIL;
1274 else if (is_renderbuffer || internalFormat == 3 || internalFormat == 4 ||
1275 internalFormat == GL_RGB || internalFormat == GL_RGBA ||
1276 internalFormat == GL_RGBA2 ||
1277 internalFormat == GL_RGB4 || internalFormat == GL_RGBA4 ||
1278 internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
1279 internalFormat == GL_BGRA ||
1280 internalFormat == GL_RGB16F ||
1281 internalFormat == GL_RGBA16F ||
1282 internalFormat == GL_RGB32F ||
1283 internalFormat == GL_RGBA32F)
1284 bindings |= PIPE_BIND_RENDER_TARGET;
1285
1286 /* GLES allows the driver to choose any format which matches
1287 * the format+type combo, because GLES only supports unsized internal
1288 * formats and expects the driver to choose whatever suits it.
1289 */
1290 if (_mesa_is_gles(ctx)) {
1291 GLenum baseFormat = _mesa_base_tex_format(ctx, internalFormat);
1292 GLenum basePackFormat = _mesa_base_pack_format(format);
1293 GLenum iformat = internalFormat;
1294
1295 /* Treat GL_BGRA as GL_RGBA. */
1296 if (iformat == GL_BGRA)
1297 iformat = GL_RGBA;
1298
1299 /* Check if the internalformat is unsized and compatible
1300 * with the "format".
1301 */
1302 if (iformat == baseFormat && iformat == basePackFormat) {
1303 pFormat = st_choose_matching_format(st, bindings, format, type,
1304 ctx->Unpack.SwapBytes);
1305
1306 if (pFormat != PIPE_FORMAT_NONE)
1307 return st_pipe_format_to_mesa_format(pFormat);
1308
1309 if (!is_renderbuffer) {
1310 /* try choosing format again, this time without render
1311 * target bindings.
1312 */
1313 pFormat = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
1314 format, type,
1315 ctx->Unpack.SwapBytes);
1316 if (pFormat != PIPE_FORMAT_NONE)
1317 return st_pipe_format_to_mesa_format(pFormat);
1318 }
1319 }
1320 }
1321
1322 pFormat = st_choose_format(st, internalFormat, format, type,
1323 pTarget, 0, 0, bindings,
1324 ctx->Unpack.SwapBytes, true);
1325
1326 if (pFormat == PIPE_FORMAT_NONE && !is_renderbuffer) {
1327 /* try choosing format again, this time without render target bindings */
1328 pFormat = st_choose_format(st, internalFormat, format, type,
1329 pTarget, 0, 0, PIPE_BIND_SAMPLER_VIEW,
1330 ctx->Unpack.SwapBytes, true);
1331 }
1332
1333 if (pFormat == PIPE_FORMAT_NONE) {
1334 mFormat = _mesa_glenum_to_compressed_format(internalFormat);
1335 if (st_compressed_format_fallback(st, mFormat))
1336 return mFormat;
1337
1338 /* no luck at all */
1339 return MESA_FORMAT_NONE;
1340 }
1341
1342 mFormat = st_pipe_format_to_mesa_format(pFormat);
1343
1344 /* Debugging aid */
1345 if (0) {
1346 debug_printf("%s(intFormat=%s, format=%s, type=%s) -> %s, %s\n",
1347 __func__,
1348 _mesa_enum_to_string(internalFormat),
1349 _mesa_enum_to_string(format),
1350 _mesa_enum_to_string(type),
1351 util_format_name(pFormat),
1352 _mesa_get_format_name(mFormat));
1353 }
1354
1355 return mFormat;
1356 }
1357
1358
1359 /**
1360 * Called via ctx->Driver.QueryInternalFormat().
1361 */
1362 static size_t
1363 st_QuerySamplesForFormat(struct gl_context *ctx, GLenum target,
1364 GLenum internalFormat, int samples[16])
1365 {
1366 struct st_context *st = st_context(ctx);
1367 enum pipe_format format;
1368 unsigned i, bind, num_sample_counts = 0;
1369
1370 (void) target;
1371
1372 if (_mesa_is_depth_or_stencil_format(internalFormat))
1373 bind = PIPE_BIND_DEPTH_STENCIL;
1374 else
1375 bind = PIPE_BIND_RENDER_TARGET;
1376
1377 /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
1378 * formats.
1379 */
1380 if (!ctx->Extensions.EXT_sRGB) {
1381 internalFormat = _mesa_get_linear_internalformat(internalFormat);
1382 }
1383
1384 /* Set sample counts in descending order. */
1385 for (i = 16; i > 1; i--) {
1386 format = st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
1387 PIPE_TEXTURE_2D, i, i, bind,
1388 false, false);
1389
1390 if (format != PIPE_FORMAT_NONE) {
1391 samples[num_sample_counts++] = i;
1392 }
1393 }
1394
1395 if (!num_sample_counts) {
1396 samples[num_sample_counts++] = 1;
1397 }
1398
1399 return num_sample_counts;
1400 }
1401
1402
1403 /**
1404 * ARB_internalformat_query2 driver hook.
1405 */
1406 void
1407 st_QueryInternalFormat(struct gl_context *ctx, GLenum target,
1408 GLenum internalFormat, GLenum pname, GLint *params)
1409 {
1410 struct st_context *st = st_context(ctx);
1411 /* The API entry-point gives us a temporary params buffer that is non-NULL
1412 * and guaranteed to have at least 16 elements.
1413 */
1414 assert(params != NULL);
1415
1416 switch (pname) {
1417 case GL_SAMPLES:
1418 st_QuerySamplesForFormat(ctx, target, internalFormat, params);
1419 break;
1420
1421 case GL_NUM_SAMPLE_COUNTS: {
1422 int samples[16];
1423 size_t num_samples;
1424 num_samples = st_QuerySamplesForFormat(ctx, target, internalFormat,
1425 samples);
1426 params[0] = (GLint) num_samples;
1427 break;
1428 }
1429 case GL_INTERNALFORMAT_PREFERRED: {
1430 params[0] = GL_NONE;
1431
1432 /* We need to resolve an internal format that is compatible with
1433 * the passed internal format, and optimal to the driver. By now,
1434 * we just validate that the passed internal format is supported by
1435 * the driver, and if so return the same internal format, otherwise
1436 * return GL_NONE.
1437 */
1438 unsigned bindings;
1439 if (_mesa_is_depth_or_stencil_format(internalFormat))
1440 bindings = PIPE_BIND_DEPTH_STENCIL;
1441 else
1442 bindings = PIPE_BIND_RENDER_TARGET;
1443 enum pipe_format pformat = st_choose_format(st,
1444 internalFormat,
1445 GL_NONE,
1446 GL_NONE,
1447 PIPE_TEXTURE_2D, 0, 0,
1448 bindings,
1449 false, false);
1450 if (pformat)
1451 params[0] = internalFormat;
1452 break;
1453 }
1454 default:
1455 /* For the rest of the pnames, we call back the Mesa's default
1456 * function for drivers that don't implement ARB_internalformat_query2.
1457 */
1458 _mesa_query_internal_format_default(ctx, target, internalFormat, pname,
1459 params);
1460 }
1461 }
1462
1463
1464 /**
1465 * This is used for translating texture border color and the clear
1466 * color. For example, the clear color is interpreted according to
1467 * the renderbuffer's base format. For example, if clearing a
1468 * GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
1469 * colorOut[2] = colorIn[0].
1470 * Similarly for texture border colors.
1471 */
1472 void
1473 st_translate_color(const union gl_color_union *colorIn,
1474 union pipe_color_union *colorOut,
1475 GLenum baseFormat, GLboolean is_integer)
1476 {
1477 if (is_integer) {
1478 const int *in = colorIn->i;
1479 int *out = colorOut->i;
1480
1481 switch (baseFormat) {
1482 case GL_RED:
1483 out[0] = in[0];
1484 out[1] = 0;
1485 out[2] = 0;
1486 out[3] = 1;
1487 break;
1488 case GL_RG:
1489 out[0] = in[0];
1490 out[1] = in[1];
1491 out[2] = 0;
1492 out[3] = 1;
1493 break;
1494 case GL_RGB:
1495 out[0] = in[0];
1496 out[1] = in[1];
1497 out[2] = in[2];
1498 out[3] = 1;
1499 break;
1500 case GL_ALPHA:
1501 out[0] = out[1] = out[2] = 0;
1502 out[3] = in[3];
1503 break;
1504 case GL_LUMINANCE:
1505 out[0] = out[1] = out[2] = in[0];
1506 out[3] = 1;
1507 break;
1508 case GL_LUMINANCE_ALPHA:
1509 out[0] = out[1] = out[2] = in[0];
1510 out[3] = in[3];
1511 break;
1512 case GL_INTENSITY:
1513 out[0] = out[1] = out[2] = out[3] = in[0];
1514 break;
1515 default:
1516 COPY_4V(out, in);
1517 }
1518 }
1519 else {
1520 const float *in = colorIn->f;
1521 float *out = colorOut->f;
1522
1523 switch (baseFormat) {
1524 case GL_RED:
1525 out[0] = in[0];
1526 out[1] = 0.0F;
1527 out[2] = 0.0F;
1528 out[3] = 1.0F;
1529 break;
1530 case GL_RG:
1531 out[0] = in[0];
1532 out[1] = in[1];
1533 out[2] = 0.0F;
1534 out[3] = 1.0F;
1535 break;
1536 case GL_RGB:
1537 out[0] = in[0];
1538 out[1] = in[1];
1539 out[2] = in[2];
1540 out[3] = 1.0F;
1541 break;
1542 case GL_ALPHA:
1543 out[0] = out[1] = out[2] = 0.0F;
1544 out[3] = in[3];
1545 break;
1546 case GL_LUMINANCE:
1547 out[0] = out[1] = out[2] = in[0];
1548 out[3] = 1.0F;
1549 break;
1550 case GL_LUMINANCE_ALPHA:
1551 out[0] = out[1] = out[2] = in[0];
1552 out[3] = in[3];
1553 break;
1554 /* Stencil border is tricky on some hw. Help drivers a little here. */
1555 case GL_STENCIL_INDEX:
1556 case GL_INTENSITY:
1557 out[0] = out[1] = out[2] = out[3] = in[0];
1558 break;
1559 default:
1560 COPY_4V(out, in);
1561 }
1562 }
1563 }