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