projects / mesa.git / blob
? search:


84bee15d44b603ee00f41e492e85795b69b1ef95
[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/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 (_mesa_is_format_astc_2d(mesaFormat) && !st->has_astc_2d_ldr) {
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 switch (format) {
127 case PIPE_FORMAT_ABGR8888_UNORM:
128 return MESA_FORMAT_A8B8G8R8_UNORM;
129 case PIPE_FORMAT_RGBA8888_UNORM:
130 return MESA_FORMAT_R8G8B8A8_UNORM;
131 case PIPE_FORMAT_R8G8B8_UNORM:
132 return MESA_FORMAT_RGB_UNORM8;
133 case PIPE_FORMAT_BGRA8888_UNORM:
134 return MESA_FORMAT_B8G8R8A8_UNORM;
135 case PIPE_FORMAT_ARGB8888_UNORM:
136 return MESA_FORMAT_A8R8G8B8_UNORM;
137 case PIPE_FORMAT_XBGR8888_UNORM:
138 return MESA_FORMAT_X8B8G8R8_UNORM;
139 case PIPE_FORMAT_RGBX8888_UNORM:
140 return MESA_FORMAT_R8G8B8X8_UNORM;
141 case PIPE_FORMAT_BGRX8888_UNORM:
142 return MESA_FORMAT_B8G8R8X8_UNORM;
143 case PIPE_FORMAT_XRGB8888_UNORM:
144 return MESA_FORMAT_X8R8G8B8_UNORM;
145 case PIPE_FORMAT_B5G5R5A1_UNORM:
146 return MESA_FORMAT_B5G5R5A1_UNORM;
147 case PIPE_FORMAT_A1B5G5R5_UNORM:
148 return MESA_FORMAT_A1B5G5R5_UNORM;
149 case PIPE_FORMAT_A1R5G5B5_UNORM:
150 return MESA_FORMAT_A1R5G5B5_UNORM;
151 case PIPE_FORMAT_R5G5B5A1_UNORM:
152 return MESA_FORMAT_R5G5B5A1_UNORM;
153 case PIPE_FORMAT_R4G4B4A4_UNORM:
154 return MESA_FORMAT_R4G4B4A4_UNORM;
155 case PIPE_FORMAT_B4G4R4A4_UNORM:
156 return MESA_FORMAT_B4G4R4A4_UNORM;
157 case PIPE_FORMAT_A4B4G4R4_UNORM:
158 return MESA_FORMAT_A4B4G4R4_UNORM;
159 case PIPE_FORMAT_A4R4G4B4_UNORM:
160 return MESA_FORMAT_A4R4G4B4_UNORM;
161 case PIPE_FORMAT_R5G6B5_UNORM:
162 return MESA_FORMAT_R5G6B5_UNORM;
163 case PIPE_FORMAT_B5G6R5_UNORM:
164 return MESA_FORMAT_B5G6R5_UNORM;
165 case PIPE_FORMAT_R3G3B2_UNORM:
166 return MESA_FORMAT_R3G3B2_UNORM;
167 case PIPE_FORMAT_B2G3R3_UNORM:
168 return MESA_FORMAT_B2G3R3_UNORM;
169 case PIPE_FORMAT_B10G10R10A2_UNORM:
170 return MESA_FORMAT_B10G10R10A2_UNORM;
171 case PIPE_FORMAT_R10G10B10A2_UNORM:
172 return MESA_FORMAT_R10G10B10A2_UNORM;
173 case PIPE_FORMAT_R10G10B10X2_UNORM:
174 return MESA_FORMAT_R10G10B10X2_UNORM;
175 case PIPE_FORMAT_A2R10G10B10_UNORM:
176 return MESA_FORMAT_A2R10G10B10_UNORM;
177 case PIPE_FORMAT_A2B10G10R10_UNORM:
178 return MESA_FORMAT_A2B10G10R10_UNORM;
179 case PIPE_FORMAT_L4A4_UNORM:
180 return MESA_FORMAT_L4A4_UNORM;
181 case PIPE_FORMAT_L8A8_UNORM:
182 return MESA_FORMAT_LA_UNORM8;
183 case PIPE_FORMAT_L16A16_UNORM:
184 return MESA_FORMAT_LA_UNORM16;
185 case PIPE_FORMAT_A8_UNORM:
186 return MESA_FORMAT_A_UNORM8;
187 case PIPE_FORMAT_A16_UNORM:
188 return MESA_FORMAT_A_UNORM16;
189 case PIPE_FORMAT_L8_UNORM:
190 return MESA_FORMAT_L_UNORM8;
191 case PIPE_FORMAT_L16_UNORM:
192 return MESA_FORMAT_L_UNORM16;
193 case PIPE_FORMAT_I8_UNORM:
194 return MESA_FORMAT_I_UNORM8;
195 case PIPE_FORMAT_I16_UNORM:
196 return MESA_FORMAT_I_UNORM16;
197 case PIPE_FORMAT_S8_UINT:
198 return MESA_FORMAT_S_UINT8;
199
200 case PIPE_FORMAT_R16G16B16A16_UNORM:
201 return MESA_FORMAT_RGBA_UNORM16;
202
203 case PIPE_FORMAT_Z16_UNORM:
204 return MESA_FORMAT_Z_UNORM16;
205 case PIPE_FORMAT_Z32_UNORM:
206 return MESA_FORMAT_Z_UNORM32;
207 case PIPE_FORMAT_S8_UINT_Z24_UNORM:
208 return MESA_FORMAT_S8_UINT_Z24_UNORM;
209 case PIPE_FORMAT_X8Z24_UNORM:
210 return MESA_FORMAT_X8_UINT_Z24_UNORM;
211 case PIPE_FORMAT_Z24X8_UNORM:
212 return MESA_FORMAT_Z24_UNORM_X8_UINT;
213 case PIPE_FORMAT_Z24_UNORM_S8_UINT:
214 return MESA_FORMAT_Z24_UNORM_S8_UINT;
215 case PIPE_FORMAT_Z32_FLOAT:
216 return MESA_FORMAT_Z_FLOAT32;
217 case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
218 return MESA_FORMAT_Z32_FLOAT_S8X24_UINT;
219
220 case PIPE_FORMAT_UYVY:
221 return MESA_FORMAT_YCBCR;
222 case PIPE_FORMAT_YUYV:
223 return MESA_FORMAT_YCBCR_REV;
224
225 case PIPE_FORMAT_DXT1_RGB:
226 return MESA_FORMAT_RGB_DXT1;
227 case PIPE_FORMAT_DXT1_RGBA:
228 return MESA_FORMAT_RGBA_DXT1;
229 case PIPE_FORMAT_DXT3_RGBA:
230 return MESA_FORMAT_RGBA_DXT3;
231 case PIPE_FORMAT_DXT5_RGBA:
232 return MESA_FORMAT_RGBA_DXT5;
233 case PIPE_FORMAT_DXT1_SRGB:
234 return MESA_FORMAT_SRGB_DXT1;
235 case PIPE_FORMAT_DXT1_SRGBA:
236 return MESA_FORMAT_SRGBA_DXT1;
237 case PIPE_FORMAT_DXT3_SRGBA:
238 return MESA_FORMAT_SRGBA_DXT3;
239 case PIPE_FORMAT_DXT5_SRGBA:
240 return MESA_FORMAT_SRGBA_DXT5;
241 case PIPE_FORMAT_L8_SRGB:
242 return MESA_FORMAT_L_SRGB8;
243 case PIPE_FORMAT_L8A8_SRGB:
244 return MESA_FORMAT_LA_SRGB8;
245 case PIPE_FORMAT_R8_SRGB:
246 return MESA_FORMAT_R_SRGB8;
247 case PIPE_FORMAT_R8G8B8_SRGB:
248 return MESA_FORMAT_BGR_SRGB8;
249 case PIPE_FORMAT_ABGR8888_SRGB:
250 return MESA_FORMAT_A8B8G8R8_SRGB;
251 case PIPE_FORMAT_RGBA8888_SRGB:
252 return MESA_FORMAT_R8G8B8A8_SRGB;
253 case PIPE_FORMAT_BGRA8888_SRGB:
254 return MESA_FORMAT_B8G8R8A8_SRGB;
255 case PIPE_FORMAT_ARGB8888_SRGB:
256 return MESA_FORMAT_A8R8G8B8_SRGB;
257 case PIPE_FORMAT_R32G32B32A32_FLOAT:
258 return MESA_FORMAT_RGBA_FLOAT32;
259 case PIPE_FORMAT_R16G16B16A16_FLOAT:
260 return MESA_FORMAT_RGBA_FLOAT16;
261 case PIPE_FORMAT_R32G32B32_FLOAT:
262 return MESA_FORMAT_RGB_FLOAT32;
263 case PIPE_FORMAT_R16G16B16_FLOAT:
264 return MESA_FORMAT_RGB_FLOAT16;
265 case PIPE_FORMAT_L32A32_FLOAT:
266 return MESA_FORMAT_LA_FLOAT32;
267 case PIPE_FORMAT_L16A16_FLOAT:
268 return MESA_FORMAT_LA_FLOAT16;
269 case PIPE_FORMAT_L32_FLOAT:
270 return MESA_FORMAT_L_FLOAT32;
271 case PIPE_FORMAT_L16_FLOAT:
272 return MESA_FORMAT_L_FLOAT16;
273 case PIPE_FORMAT_A32_FLOAT:
274 return MESA_FORMAT_A_FLOAT32;
275 case PIPE_FORMAT_A16_FLOAT:
276 return MESA_FORMAT_A_FLOAT16;
277 case PIPE_FORMAT_I32_FLOAT:
278 return MESA_FORMAT_I_FLOAT32;
279 case PIPE_FORMAT_I16_FLOAT:
280 return MESA_FORMAT_I_FLOAT16;
281 case PIPE_FORMAT_R32_FLOAT:
282 return MESA_FORMAT_R_FLOAT32;
283 case PIPE_FORMAT_R16_FLOAT:
284 return MESA_FORMAT_R_FLOAT16;
285 case PIPE_FORMAT_R32G32_FLOAT:
286 return MESA_FORMAT_RG_FLOAT32;
287 case PIPE_FORMAT_R16G16_FLOAT:
288 return MESA_FORMAT_RG_FLOAT16;
289
290 case PIPE_FORMAT_R8_UNORM:
291 return MESA_FORMAT_R_UNORM8;
292 case PIPE_FORMAT_R16_UNORM:
293 return MESA_FORMAT_R_UNORM16;
294 case PIPE_FORMAT_R8G8_UNORM:
295 return MESA_FORMAT_RG_UNORM8;
296 case PIPE_FORMAT_R16G16_UNORM:
297 return MESA_FORMAT_RG_UNORM16;
298 case PIPE_FORMAT_B8G8R8_UNORM:
299 return MESA_FORMAT_BGR_UNORM8;
300
301 case PIPE_FORMAT_A8_UINT:
302 return MESA_FORMAT_A_UINT8;
303 case PIPE_FORMAT_A16_UINT:
304 return MESA_FORMAT_A_UINT16;
305 case PIPE_FORMAT_A32_UINT:
306 return MESA_FORMAT_A_UINT32;
307 case PIPE_FORMAT_A8_SINT:
308 return MESA_FORMAT_A_SINT8;
309 case PIPE_FORMAT_A16_SINT:
310 return MESA_FORMAT_A_SINT16;
311 case PIPE_FORMAT_A32_SINT:
312 return MESA_FORMAT_A_SINT32;
313
314 case PIPE_FORMAT_I8_UINT:
315 return MESA_FORMAT_I_UINT8;
316 case PIPE_FORMAT_I16_UINT:
317 return MESA_FORMAT_I_UINT16;
318 case PIPE_FORMAT_I32_UINT:
319 return MESA_FORMAT_I_UINT32;
320 case PIPE_FORMAT_I8_SINT:
321 return MESA_FORMAT_I_SINT8;
322 case PIPE_FORMAT_I16_SINT:
323 return MESA_FORMAT_I_SINT16;
324 case PIPE_FORMAT_I32_SINT:
325 return MESA_FORMAT_I_SINT32;
326
327 case PIPE_FORMAT_L8_UINT:
328 return MESA_FORMAT_L_UINT8;
329 case PIPE_FORMAT_L16_UINT:
330 return MESA_FORMAT_L_UINT16;
331 case PIPE_FORMAT_L32_UINT:
332 return MESA_FORMAT_L_UINT32;
333 case PIPE_FORMAT_L8_SINT:
334 return MESA_FORMAT_L_SINT8;
335 case PIPE_FORMAT_L16_SINT:
336 return MESA_FORMAT_L_SINT16;
337 case PIPE_FORMAT_L32_SINT:
338 return MESA_FORMAT_L_SINT32;
339
340 case PIPE_FORMAT_L8A8_UINT:
341 return MESA_FORMAT_LA_UINT8;
342 case PIPE_FORMAT_L16A16_UINT:
343 return MESA_FORMAT_LA_UINT16;
344 case PIPE_FORMAT_L32A32_UINT:
345 return MESA_FORMAT_LA_UINT32;
346 case PIPE_FORMAT_L8A8_SINT:
347 return MESA_FORMAT_LA_SINT8;
348 case PIPE_FORMAT_L16A16_SINT:
349 return MESA_FORMAT_LA_SINT16;
350 case PIPE_FORMAT_L32A32_SINT:
351 return MESA_FORMAT_LA_SINT32;
352
353 case PIPE_FORMAT_R8_SINT:
354 return MESA_FORMAT_R_SINT8;
355 case PIPE_FORMAT_R8G8_SINT:
356 return MESA_FORMAT_RG_SINT8;
357 case PIPE_FORMAT_R8G8B8_SINT:
358 return MESA_FORMAT_RGB_SINT8;
359 case PIPE_FORMAT_R8G8B8A8_SINT:
360 return MESA_FORMAT_RGBA_SINT8;
361
362 case PIPE_FORMAT_R16_SINT:
363 return MESA_FORMAT_R_SINT16;
364 case PIPE_FORMAT_R16G16_SINT:
365 return MESA_FORMAT_RG_SINT16;
366 case PIPE_FORMAT_R16G16B16_SINT:
367 return MESA_FORMAT_RGB_SINT16;
368 case PIPE_FORMAT_R16G16B16A16_SINT:
369 return MESA_FORMAT_RGBA_SINT16;
370
371 case PIPE_FORMAT_R32_SINT:
372 return MESA_FORMAT_R_SINT32;
373 case PIPE_FORMAT_R32G32_SINT:
374 return MESA_FORMAT_RG_SINT32;
375 case PIPE_FORMAT_R32G32B32_SINT:
376 return MESA_FORMAT_RGB_SINT32;
377 case PIPE_FORMAT_R32G32B32A32_SINT:
378 return MESA_FORMAT_RGBA_SINT32;
379
380 /* unsigned int formats */
381 case PIPE_FORMAT_R8_UINT:
382 return MESA_FORMAT_R_UINT8;
383 case PIPE_FORMAT_R8G8_UINT:
384 return MESA_FORMAT_RG_UINT8;
385 case PIPE_FORMAT_R8G8B8_UINT:
386 return MESA_FORMAT_RGB_UINT8;
387
388 case PIPE_FORMAT_R16_UINT:
389 return MESA_FORMAT_R_UINT16;
390 case PIPE_FORMAT_R16G16_UINT:
391 return MESA_FORMAT_RG_UINT16;
392 case PIPE_FORMAT_R16G16B16_UINT:
393 return MESA_FORMAT_RGB_UINT16;
394 case PIPE_FORMAT_R16G16B16A16_UINT:
395 return MESA_FORMAT_RGBA_UINT16;
396
397 case PIPE_FORMAT_R32_UINT:
398 return MESA_FORMAT_R_UINT32;
399 case PIPE_FORMAT_R32G32_UINT:
400 return MESA_FORMAT_RG_UINT32;
401 case PIPE_FORMAT_R32G32B32_UINT:
402 return MESA_FORMAT_RGB_UINT32;
403 case PIPE_FORMAT_R32G32B32A32_UINT:
404 return MESA_FORMAT_RGBA_UINT32;
405
406 case PIPE_FORMAT_RGTC1_UNORM:
407 return MESA_FORMAT_R_RGTC1_UNORM;
408 case PIPE_FORMAT_RGTC1_SNORM:
409 return MESA_FORMAT_R_RGTC1_SNORM;
410 case PIPE_FORMAT_RGTC2_UNORM:
411 return MESA_FORMAT_RG_RGTC2_UNORM;
412 case PIPE_FORMAT_RGTC2_SNORM:
413 return MESA_FORMAT_RG_RGTC2_SNORM;
414
415 case PIPE_FORMAT_LATC1_UNORM:
416 return MESA_FORMAT_L_LATC1_UNORM;
417 case PIPE_FORMAT_LATC1_SNORM:
418 return MESA_FORMAT_L_LATC1_SNORM;
419 case PIPE_FORMAT_LATC2_UNORM:
420 return MESA_FORMAT_LA_LATC2_UNORM;
421 case PIPE_FORMAT_LATC2_SNORM:
422 return MESA_FORMAT_LA_LATC2_SNORM;
423
424 case PIPE_FORMAT_ETC1_RGB8:
425 return MESA_FORMAT_ETC1_RGB8;
426
427 case PIPE_FORMAT_BPTC_RGBA_UNORM:
428 return MESA_FORMAT_BPTC_RGBA_UNORM;
429 case PIPE_FORMAT_BPTC_SRGBA:
430 return MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM;
431 case PIPE_FORMAT_BPTC_RGB_FLOAT:
432 return MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT;
433 case PIPE_FORMAT_BPTC_RGB_UFLOAT:
434 return MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT;
435
436 /* signed normalized formats */
437 case PIPE_FORMAT_R8_SNORM:
438 return MESA_FORMAT_R_SNORM8;
439 case PIPE_FORMAT_R8G8_SNORM:
440 return MESA_FORMAT_RG_SNORM8;
441 case PIPE_FORMAT_RGBA8888_SNORM:
442 return MESA_FORMAT_R8G8B8A8_SNORM;
443 case PIPE_FORMAT_ABGR8888_SNORM:
444 return MESA_FORMAT_A8B8G8R8_SNORM;
445
446 case PIPE_FORMAT_A8_SNORM:
447 return MESA_FORMAT_A_SNORM8;
448 case PIPE_FORMAT_L8_SNORM:
449 return MESA_FORMAT_L_SNORM8;
450 case PIPE_FORMAT_L8A8_SNORM:
451 return MESA_FORMAT_LA_SNORM8;
452 case PIPE_FORMAT_I8_SNORM:
453 return MESA_FORMAT_I_SNORM8;
454
455 case PIPE_FORMAT_R16_SNORM:
456 return MESA_FORMAT_R_SNORM16;
457 case PIPE_FORMAT_R16G16_SNORM:
458 return MESA_FORMAT_RG_SNORM16;
459 case PIPE_FORMAT_R16G16B16_SNORM:
460 return MESA_FORMAT_RGB_SNORM16;
461 case PIPE_FORMAT_R16G16B16A16_SNORM:
462 return MESA_FORMAT_RGBA_SNORM16;
463
464 case PIPE_FORMAT_A16_SNORM:
465 return MESA_FORMAT_A_SNORM16;
466 case PIPE_FORMAT_L16_SNORM:
467 return MESA_FORMAT_L_SNORM16;
468 case PIPE_FORMAT_L16A16_SNORM:
469 return MESA_FORMAT_LA_SNORM16;
470 case PIPE_FORMAT_I16_SNORM:
471 return MESA_FORMAT_I_SNORM16;
472
473 case PIPE_FORMAT_R9G9B9E5_FLOAT:
474 return MESA_FORMAT_R9G9B9E5_FLOAT;
475 case PIPE_FORMAT_R11G11B10_FLOAT:
476 return MESA_FORMAT_R11G11B10_FLOAT;
477
478 case PIPE_FORMAT_RGBA8888_UINT:
479 return MESA_FORMAT_R8G8B8A8_UINT;
480 case PIPE_FORMAT_BGRA8888_UINT:
481 return MESA_FORMAT_B8G8R8A8_UINT;
482 case PIPE_FORMAT_ARGB8888_UINT:
483 return MESA_FORMAT_A8R8G8B8_UINT;
484 case PIPE_FORMAT_ABGR8888_UINT:
485 return MESA_FORMAT_A8B8G8R8_UINT;
486 case PIPE_FORMAT_B10G10R10A2_UINT:
487 return MESA_FORMAT_B10G10R10A2_UINT;
488 case PIPE_FORMAT_R10G10B10A2_UINT:
489 return MESA_FORMAT_R10G10B10A2_UINT;
490 case PIPE_FORMAT_A2R10G10B10_UINT:
491 return MESA_FORMAT_A2R10G10B10_UINT;
492 case PIPE_FORMAT_A2B10G10R10_UINT:
493 return MESA_FORMAT_A2B10G10R10_UINT;
494 case PIPE_FORMAT_R5G5B5A1_UINT:
495 return MESA_FORMAT_R5G5B5A1_UINT;
496 case PIPE_FORMAT_B5G5R5A1_UINT:
497 return MESA_FORMAT_B5G5R5A1_UINT;
498 case PIPE_FORMAT_A1R5G5B5_UINT:
499 return MESA_FORMAT_A1R5G5B5_UINT;
500 case PIPE_FORMAT_A1B5G5R5_UINT:
501 return MESA_FORMAT_A1B5G5R5_UINT;
502 case PIPE_FORMAT_R4G4B4A4_UINT:
503 return MESA_FORMAT_R4G4B4A4_UINT;
504 case PIPE_FORMAT_B4G4R4A4_UINT:
505 return MESA_FORMAT_B4G4R4A4_UINT;
506 case PIPE_FORMAT_A4B4G4R4_UINT:
507 return MESA_FORMAT_A4B4G4R4_UINT;
508 case PIPE_FORMAT_A4R4G4B4_UINT:
509 return MESA_FORMAT_A4R4G4B4_UINT;
510 case PIPE_FORMAT_R5G6B5_UINT:
511 return MESA_FORMAT_R5G6B5_UINT;
512 case PIPE_FORMAT_B5G6R5_UINT:
513 return MESA_FORMAT_B5G6R5_UINT;
514 case PIPE_FORMAT_R3G3B2_UINT:
515 return MESA_FORMAT_R3G3B2_UINT;
516 case PIPE_FORMAT_B2G3R3_UINT:
517 return MESA_FORMAT_B2G3R3_UINT;
518
519 case PIPE_FORMAT_B4G4R4X4_UNORM:
520 return MESA_FORMAT_B4G4R4X4_UNORM;
521 case PIPE_FORMAT_B5G5R5X1_UNORM:
522 return MESA_FORMAT_B5G5R5X1_UNORM;
523 case PIPE_FORMAT_X1B5G5R5_UNORM:
524 return MESA_FORMAT_X1B5G5R5_UNORM;
525 case PIPE_FORMAT_RGBX8888_SNORM:
526 return MESA_FORMAT_R8G8B8X8_SNORM;
527 case PIPE_FORMAT_XBGR8888_SNORM:
528 return MESA_FORMAT_X8B8G8R8_SNORM;
529 case PIPE_FORMAT_RGBX8888_SRGB:
530 return MESA_FORMAT_R8G8B8X8_SRGB;
531 case PIPE_FORMAT_XBGR8888_SRGB:
532 return MESA_FORMAT_X8B8G8R8_SRGB;
533 case PIPE_FORMAT_R8G8B8X8_UINT:
534 return MESA_FORMAT_RGBX_UINT8;
535 case PIPE_FORMAT_R8G8B8X8_SINT:
536 return MESA_FORMAT_RGBX_SINT8;
537 case PIPE_FORMAT_B10G10R10X2_UNORM:
538 return MESA_FORMAT_B10G10R10X2_UNORM;
539 case PIPE_FORMAT_R16G16B16X16_UNORM:
540 return MESA_FORMAT_RGBX_UNORM16;
541 case PIPE_FORMAT_R16G16B16X16_SNORM:
542 return MESA_FORMAT_RGBX_SNORM16;
543 case PIPE_FORMAT_R16G16B16X16_FLOAT:
544 return MESA_FORMAT_RGBX_FLOAT16;
545 case PIPE_FORMAT_R16G16B16X16_UINT:
546 return MESA_FORMAT_RGBX_UINT16;
547 case PIPE_FORMAT_R16G16B16X16_SINT:
548 return MESA_FORMAT_RGBX_SINT16;
549 case PIPE_FORMAT_R32G32B32X32_FLOAT:
550 return MESA_FORMAT_RGBX_FLOAT32;
551 case PIPE_FORMAT_R32G32B32X32_UINT:
552 return MESA_FORMAT_RGBX_UINT32;
553 case PIPE_FORMAT_R32G32B32X32_SINT:
554 return MESA_FORMAT_RGBX_SINT32;
555
556 case PIPE_FORMAT_BGRX8888_SRGB:
557 return MESA_FORMAT_B8G8R8X8_SRGB;
558 case PIPE_FORMAT_XRGB8888_SRGB:
559 return MESA_FORMAT_X8R8G8B8_SRGB;
560
561 case PIPE_FORMAT_ETC2_RGB8:
562 return MESA_FORMAT_ETC2_RGB8;
563 case PIPE_FORMAT_ETC2_SRGB8:
564 return MESA_FORMAT_ETC2_SRGB8;
565 case PIPE_FORMAT_ETC2_RGB8A1:
566 return MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
567 case PIPE_FORMAT_ETC2_SRGB8A1:
568 return MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
569 case PIPE_FORMAT_ETC2_RGBA8:
570 return MESA_FORMAT_ETC2_RGBA8_EAC;
571 case PIPE_FORMAT_ETC2_SRGBA8:
572 return MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC;
573 case PIPE_FORMAT_ETC2_R11_UNORM:
574 return MESA_FORMAT_ETC2_R11_EAC;
575 case PIPE_FORMAT_ETC2_R11_SNORM:
576 return MESA_FORMAT_ETC2_SIGNED_R11_EAC;
577 case PIPE_FORMAT_ETC2_RG11_UNORM:
578 return MESA_FORMAT_ETC2_RG11_EAC;
579 case PIPE_FORMAT_ETC2_RG11_SNORM:
580 return MESA_FORMAT_ETC2_SIGNED_RG11_EAC;
581
582 case PIPE_FORMAT_ASTC_4x4:
583 return MESA_FORMAT_RGBA_ASTC_4x4;
584 case PIPE_FORMAT_ASTC_5x4:
585 return MESA_FORMAT_RGBA_ASTC_5x4;
586 case PIPE_FORMAT_ASTC_5x5:
587 return MESA_FORMAT_RGBA_ASTC_5x5;
588 case PIPE_FORMAT_ASTC_6x5:
589 return MESA_FORMAT_RGBA_ASTC_6x5;
590 case PIPE_FORMAT_ASTC_6x6:
591 return MESA_FORMAT_RGBA_ASTC_6x6;
592 case PIPE_FORMAT_ASTC_8x5:
593 return MESA_FORMAT_RGBA_ASTC_8x5;
594 case PIPE_FORMAT_ASTC_8x6:
595 return MESA_FORMAT_RGBA_ASTC_8x6;
596 case PIPE_FORMAT_ASTC_8x8:
597 return MESA_FORMAT_RGBA_ASTC_8x8;
598 case PIPE_FORMAT_ASTC_10x5:
599 return MESA_FORMAT_RGBA_ASTC_10x5;
600 case PIPE_FORMAT_ASTC_10x6:
601 return MESA_FORMAT_RGBA_ASTC_10x6;
602 case PIPE_FORMAT_ASTC_10x8:
603 return MESA_FORMAT_RGBA_ASTC_10x8;
604 case PIPE_FORMAT_ASTC_10x10:
605 return MESA_FORMAT_RGBA_ASTC_10x10;
606 case PIPE_FORMAT_ASTC_12x10:
607 return MESA_FORMAT_RGBA_ASTC_12x10;
608 case PIPE_FORMAT_ASTC_12x12:
609 return MESA_FORMAT_RGBA_ASTC_12x12;
610
611 case PIPE_FORMAT_ASTC_4x4_SRGB:
612 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4;
613 case PIPE_FORMAT_ASTC_5x4_SRGB:
614 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4;
615 case PIPE_FORMAT_ASTC_5x5_SRGB:
616 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5;
617 case PIPE_FORMAT_ASTC_6x5_SRGB:
618 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5;
619 case PIPE_FORMAT_ASTC_6x6_SRGB:
620 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6;
621 case PIPE_FORMAT_ASTC_8x5_SRGB:
622 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5;
623 case PIPE_FORMAT_ASTC_8x6_SRGB:
624 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6;
625 case PIPE_FORMAT_ASTC_8x8_SRGB:
626 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8;
627 case PIPE_FORMAT_ASTC_10x5_SRGB:
628 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5;
629 case PIPE_FORMAT_ASTC_10x6_SRGB:
630 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6;
631 case PIPE_FORMAT_ASTC_10x8_SRGB:
632 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8;
633 case PIPE_FORMAT_ASTC_10x10_SRGB:
634 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10;
635 case PIPE_FORMAT_ASTC_12x10_SRGB:
636 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10;
637 case PIPE_FORMAT_ASTC_12x12_SRGB:
638 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12;
639
640 case PIPE_FORMAT_ASTC_3x3x3:
641 return MESA_FORMAT_RGBA_ASTC_3x3x3;
642 case PIPE_FORMAT_ASTC_4x3x3:
643 return MESA_FORMAT_RGBA_ASTC_4x3x3;
644 case PIPE_FORMAT_ASTC_4x4x3:
645 return MESA_FORMAT_RGBA_ASTC_4x4x3;
646 case PIPE_FORMAT_ASTC_4x4x4:
647 return MESA_FORMAT_RGBA_ASTC_4x4x4;
648 case PIPE_FORMAT_ASTC_5x4x4:
649 return MESA_FORMAT_RGBA_ASTC_5x4x4;
650 case PIPE_FORMAT_ASTC_5x5x4:
651 return MESA_FORMAT_RGBA_ASTC_5x5x4;
652 case PIPE_FORMAT_ASTC_5x5x5:
653 return MESA_FORMAT_RGBA_ASTC_5x5x5;
654 case PIPE_FORMAT_ASTC_6x5x5:
655 return MESA_FORMAT_RGBA_ASTC_6x5x5;
656 case PIPE_FORMAT_ASTC_6x6x5:
657 return MESA_FORMAT_RGBA_ASTC_6x6x5;
658 case PIPE_FORMAT_ASTC_6x6x6:
659 return MESA_FORMAT_RGBA_ASTC_6x6x6;
660 case PIPE_FORMAT_ASTC_3x3x3_SRGB:
661 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_3x3x3;
662 case PIPE_FORMAT_ASTC_4x3x3_SRGB:
663 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x3x3;
664 case PIPE_FORMAT_ASTC_4x4x3_SRGB:
665 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x3;
666 case PIPE_FORMAT_ASTC_4x4x4_SRGB:
667 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4x4;
668 case PIPE_FORMAT_ASTC_5x4x4_SRGB:
669 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4x4;
670 case PIPE_FORMAT_ASTC_5x5x4_SRGB:
671 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x4;
672 case PIPE_FORMAT_ASTC_5x5x5_SRGB:
673 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5x5;
674 case PIPE_FORMAT_ASTC_6x5x5_SRGB:
675 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5x5;
676 case PIPE_FORMAT_ASTC_6x6x5_SRGB:
677 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x5;
678 case PIPE_FORMAT_ASTC_6x6x6_SRGB:
679 return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6x6;
680
681 case PIPE_FORMAT_ATC_RGB:
682 return MESA_FORMAT_ATC_RGB;
683 case PIPE_FORMAT_ATC_RGBA_EXPLICIT:
684 return MESA_FORMAT_ATC_RGBA_EXPLICIT;
685 case PIPE_FORMAT_ATC_RGBA_INTERPOLATED:
686 return MESA_FORMAT_ATC_RGBA_INTERPOLATED;
687
688 case PIPE_FORMAT_FXT1_RGB:
689 return MESA_FORMAT_RGB_FXT1;
690 case PIPE_FORMAT_FXT1_RGBA:
691 return MESA_FORMAT_RGBA_FXT1;
692
693 default:
694 return MESA_FORMAT_NONE;
695 }
696 }
697
698 /**
699 * Map GL texture formats to Gallium pipe formats.
700 */
701 struct format_mapping
702 {
703 GLenum glFormats[18]; /**< list of GLenum formats, 0-terminated */
704 enum pipe_format pipeFormats[14]; /**< list of pipe formats, 0-terminated */
705 };
706
707
708 #define DEFAULT_RGBA_FORMATS \
709 PIPE_FORMAT_R8G8B8A8_UNORM, \
710 PIPE_FORMAT_B8G8R8A8_UNORM, \
711 PIPE_FORMAT_A8R8G8B8_UNORM, \
712 PIPE_FORMAT_A8B8G8R8_UNORM, \
713 0
714
715 #define DEFAULT_RGB_FORMATS \
716 PIPE_FORMAT_R8G8B8X8_UNORM, \
717 PIPE_FORMAT_B8G8R8X8_UNORM, \
718 PIPE_FORMAT_X8R8G8B8_UNORM, \
719 PIPE_FORMAT_X8B8G8R8_UNORM, \
720 PIPE_FORMAT_B5G6R5_UNORM, \
721 DEFAULT_RGBA_FORMATS
722
723 #define DEFAULT_SRGBA_FORMATS \
724 PIPE_FORMAT_R8G8B8A8_SRGB, \
725 PIPE_FORMAT_B8G8R8A8_SRGB, \
726 PIPE_FORMAT_A8R8G8B8_SRGB, \
727 PIPE_FORMAT_A8B8G8R8_SRGB, \
728 0
729
730 #define DEFAULT_DEPTH_FORMATS \
731 PIPE_FORMAT_Z24X8_UNORM, \
732 PIPE_FORMAT_X8Z24_UNORM, \
733 PIPE_FORMAT_Z16_UNORM, \
734 PIPE_FORMAT_Z24_UNORM_S8_UINT, \
735 PIPE_FORMAT_S8_UINT_Z24_UNORM, \
736 0
737
738 #define DEFAULT_SNORM8_RGBA_FORMATS \
739 PIPE_FORMAT_R8G8B8A8_SNORM, \
740 0
741
742 #define DEFAULT_UNORM16_RGBA_FORMATS \
743 PIPE_FORMAT_R16G16B16A16_UNORM, \
744 DEFAULT_RGBA_FORMATS
745
746
747 /**
748 * This table maps OpenGL texture format enums to Gallium pipe_format enums.
749 * Multiple GL enums might map to multiple pipe_formats.
750 * The first pipe format in the list that's supported is the one that's chosen.
751 */
752 static const struct format_mapping format_map[] = {
753 /* Basic RGB, RGBA formats */
754 {
755 { GL_RGB10, 0 },
756 { PIPE_FORMAT_R10G10B10X2_UNORM, PIPE_FORMAT_B10G10R10X2_UNORM,
757 PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
758 DEFAULT_RGB_FORMATS }
759 },
760 {
761 { GL_RGB10_A2, 0 },
762 { PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
763 DEFAULT_RGBA_FORMATS }
764 },
765 {
766 { 4, GL_RGBA, GL_RGBA8, 0 },
767 { PIPE_FORMAT_R8G8B8A8_UNORM, DEFAULT_RGBA_FORMATS }
768 },
769 {
770 { GL_BGRA, 0 },
771 { DEFAULT_RGBA_FORMATS }
772 },
773 {
774 { 3, GL_RGB, GL_RGB8, 0 },
775 { PIPE_FORMAT_R8G8B8X8_UNORM, DEFAULT_RGB_FORMATS }
776 },
777 {
778 { GL_RGB12, GL_RGB16, 0 },
779 { PIPE_FORMAT_R16G16B16X16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
780 DEFAULT_RGB_FORMATS }
781 },
782 {
783 { GL_RGBA12, GL_RGBA16, 0 },
784 { PIPE_FORMAT_R16G16B16A16_UNORM, DEFAULT_RGBA_FORMATS }
785 },
786 {
787 { GL_RGBA4, GL_RGBA2, 0 },
788 { PIPE_FORMAT_B4G4R4A4_UNORM, PIPE_FORMAT_A4B4G4R4_UNORM,
789 DEFAULT_RGBA_FORMATS }
790 },
791 {
792 { GL_RGB5_A1, 0 },
793 { PIPE_FORMAT_B5G5R5A1_UNORM, PIPE_FORMAT_A1B5G5R5_UNORM,
794 DEFAULT_RGBA_FORMATS }
795 },
796 {
797 { GL_R3_G3_B2, 0 },
798 { PIPE_FORMAT_B2G3R3_UNORM, PIPE_FORMAT_B5G6R5_UNORM,
799 PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGB_FORMATS }
800 },
801 {
802 { GL_RGB4 },
803 { PIPE_FORMAT_B4G4R4X4_UNORM, PIPE_FORMAT_B4G4R4A4_UNORM,
804 PIPE_FORMAT_A4B4G4R4_UNORM,
805 DEFAULT_RGB_FORMATS }
806 },
807 {
808 { GL_RGB5 },
809 { PIPE_FORMAT_B5G5R5X1_UNORM, PIPE_FORMAT_X1B5G5R5_UNORM,
810 PIPE_FORMAT_B5G5R5A1_UNORM, PIPE_FORMAT_A1B5G5R5_UNORM,
811 DEFAULT_RGB_FORMATS }
812 },
813 {
814 { GL_RGB565 },
815 { PIPE_FORMAT_B5G6R5_UNORM, DEFAULT_RGB_FORMATS }
816 },
817
818 /* basic Alpha formats */
819 {
820 { GL_ALPHA12, GL_ALPHA16, 0 },
821 { PIPE_FORMAT_A16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
822 PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
823 },
824 {
825 { GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_COMPRESSED_ALPHA, 0 },
826 { PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
827 },
828
829 /* basic Luminance formats */
830 {
831 { GL_LUMINANCE12, GL_LUMINANCE16, 0 },
832 { PIPE_FORMAT_L16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
833 PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
834 },
835 {
836 { 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 },
837 { PIPE_FORMAT_L8_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGB_FORMATS }
838 },
839
840 /* basic Luminance/Alpha formats */
841 {
842 { GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12,
843 GL_LUMINANCE16_ALPHA16, 0},
844 { PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
845 PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
846 },
847 {
848 { 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 },
849 { PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
850 },
851 {
852 { GL_LUMINANCE4_ALPHA4, 0 },
853 { PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM,
854 DEFAULT_RGBA_FORMATS }
855 },
856
857 /* basic Intensity formats */
858 {
859 { GL_INTENSITY12, GL_INTENSITY16, 0 },
860 { PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
861 PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
862 },
863 {
864 { GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8,
865 GL_COMPRESSED_INTENSITY, 0 },
866 { PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
867 },
868
869 /* YCbCr */
870 {
871 { GL_YCBCR_MESA, 0 },
872 { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 }
873 },
874
875 /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */
876 {
877 { GL_COMPRESSED_RGB, 0 },
878 { PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS }
879 },
880 {
881 { GL_COMPRESSED_RGBA, 0 },
882 { PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS }
883 },
884 {
885 { GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 },
886 { PIPE_FORMAT_DXT1_RGB, 0 }
887 },
888 {
889 { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 },
890 { PIPE_FORMAT_DXT1_RGBA, 0 }
891 },
892 {
893 { GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 },
894 { PIPE_FORMAT_DXT3_RGBA, 0 }
895 },
896 {
897 { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 },
898 { PIPE_FORMAT_DXT5_RGBA, 0 }
899 },
900
901 #if 0
902 {
903 { GL_COMPRESSED_RGB_FXT1_3DFX, 0 },
904 { PIPE_FORMAT_RGB_FXT1, 0 }
905 },
906 {
907 { GL_COMPRESSED_RGBA_FXT1_3DFX, 0 },
908 { PIPE_FORMAT_RGBA_FXT1, 0 }
909 },
910 #endif
911
912 /* Depth formats */
913 {
914 { GL_DEPTH_COMPONENT16, 0 },
915 { PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS }
916 },
917 {
918 { GL_DEPTH_COMPONENT24, 0 },
919 { PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
920 DEFAULT_DEPTH_FORMATS }
921 },
922 {
923 { GL_DEPTH_COMPONENT32, 0 },
924 { PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS }
925 },
926 {
927 { GL_DEPTH_COMPONENT, 0 },
928 { DEFAULT_DEPTH_FORMATS }
929 },
930 {
931 { GL_DEPTH_COMPONENT32F, 0 },
932 { PIPE_FORMAT_Z32_FLOAT, 0 }
933 },
934
935 /* stencil formats */
936 {
937 { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
938 GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
939 {
940 PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
941 PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
942 }
943 },
944
945 /* Depth / Stencil formats */
946 {
947 { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
948 { PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
949 },
950 {
951 { GL_DEPTH32F_STENCIL8, 0 },
952 { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
953 },
954
955 /* sRGB formats */
956 {
957 { GL_SRGB_EXT, GL_SRGB8_EXT, 0 },
958 { PIPE_FORMAT_R8G8B8X8_SRGB, PIPE_FORMAT_B8G8R8X8_SRGB,
959 DEFAULT_SRGBA_FORMATS }
960 },
961 {
962 { GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 },
963 { PIPE_FORMAT_R8G8B8A8_SRGB, DEFAULT_SRGBA_FORMATS }
964 },
965 {
966 { GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 },
967 { PIPE_FORMAT_DXT1_SRGB, PIPE_FORMAT_R8G8B8X8_SRGB,
968 PIPE_FORMAT_B8G8R8X8_SRGB, DEFAULT_SRGBA_FORMATS }
969 },
970 {
971 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 },
972 { PIPE_FORMAT_DXT1_SRGBA, 0 }
973 },
974 {
975 { GL_COMPRESSED_SRGB_ALPHA_EXT,
976 GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 },
977 { PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS }
978 },
979 {
980 { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 },
981 { PIPE_FORMAT_DXT5_SRGBA, 0 }
982 },
983 {
984 { GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT,
985 GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 },
986 { PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS }
987 },
988 {
989 { GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, GL_COMPRESSED_SLUMINANCE_EXT,
990 0 },
991 { PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS }
992 },
993 {
994 { GL_SR8_EXT, 0 },
995 { PIPE_FORMAT_R8_SRGB, 0 }
996 },
997
998 /* 16-bit float formats */
999 {
1000 { GL_RGBA16F_ARB, 0 },
1001 { PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1002 },
1003 {
1004 { GL_RGB16F_ARB, 0 },
1005 { PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16X16_FLOAT,
1006 PIPE_FORMAT_R16G16B16A16_FLOAT,
1007 PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1008 },
1009 {
1010 { GL_LUMINANCE_ALPHA16F_ARB, 0 },
1011 { PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1012 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1013 },
1014 {
1015 { GL_ALPHA16F_ARB, 0 },
1016 { PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1017 PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1018 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1019 },
1020 {
1021 { GL_INTENSITY16F_ARB, 0 },
1022 { PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1023 PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1024 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1025 },
1026 {
1027 { GL_LUMINANCE16F_ARB, 0 },
1028 { PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1029 PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1030 PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1031 },
1032 {
1033 { GL_R16F, 0 },
1034 { PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT,
1035 PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1036 PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1037 },
1038 {
1039 { GL_RG16F, 0 },
1040 { PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1041 PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1042 },
1043
1044 /* 32-bit float formats */
1045 {
1046 { GL_RGBA32F_ARB, 0 },
1047 { PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1048 },
1049 {
1050 { GL_RGB32F_ARB, 0 },
1051 { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32X32_FLOAT,
1052 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1053 },
1054 {
1055 { GL_LUMINANCE_ALPHA32F_ARB, 0 },
1056 { PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1057 },
1058 {
1059 { GL_ALPHA32F_ARB, 0 },
1060 { PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1061 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1062 },
1063 {
1064 { GL_INTENSITY32F_ARB, 0 },
1065 { PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1066 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1067 },
1068 {
1069 { GL_LUMINANCE32F_ARB, 0 },
1070 { PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1071 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1072 },
1073 {
1074 { GL_R32F, 0 },
1075 { PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT,
1076 PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1077 },
1078 {
1079 { GL_RG32F, 0 },
1080 { PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1081 },
1082
1083 /* R, RG formats */
1084 {
1085 { GL_RED, GL_R8, 0 },
1086 { PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1087 },
1088 {
1089 { GL_RG, GL_RG8, 0 },
1090 { PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1091 },
1092 {
1093 { GL_R16, 0 },
1094 { PIPE_FORMAT_R16_UNORM, PIPE_FORMAT_R16G16_UNORM,
1095 DEFAULT_UNORM16_RGBA_FORMATS }
1096 },
1097 {
1098 { GL_RG16, 0 },
1099 { PIPE_FORMAT_R16G16_UNORM, DEFAULT_UNORM16_RGBA_FORMATS }
1100 },
1101
1102 /* compressed R, RG formats */
1103 {
1104 { GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 },
1105 { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, DEFAULT_RGBA_FORMATS }
1106 },
1107 {
1108 { GL_COMPRESSED_SIGNED_RED_RGTC1, 0 },
1109 { PIPE_FORMAT_RGTC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1110 },
1111 {
1112 { GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 },
1113 { PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1114 },
1115 {
1116 { GL_COMPRESSED_SIGNED_RG_RGTC2, 0 },
1117 { PIPE_FORMAT_RGTC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1118 },
1119 {
1120 { GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 },
1121 { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGBA_FORMATS }
1122 },
1123 {
1124 { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 },
1125 { PIPE_FORMAT_LATC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1126 },
1127 {
1128 { GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
1129 GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 },
1130 { PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1131 },
1132 {
1133 { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 },
1134 { PIPE_FORMAT_LATC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1135 },
1136
1137 /* ETC1 */
1138 {
1139 { GL_ETC1_RGB8_OES, 0 },
1140 { PIPE_FORMAT_ETC1_RGB8, 0 }
1141 },
1142
1143 /* ETC2 */
1144 {
1145 { GL_COMPRESSED_RGB8_ETC2, 0 },
1146 { PIPE_FORMAT_ETC2_RGB8, 0 }
1147 },
1148 {
1149 { GL_COMPRESSED_SRGB8_ETC2, 0 },
1150 { PIPE_FORMAT_ETC2_SRGB8, 0 }
1151 },
1152 {
1153 { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1154 { PIPE_FORMAT_ETC2_RGB8A1, 0 }
1155 },
1156 {
1157 { GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1158 { PIPE_FORMAT_ETC2_SRGB8A1, 0 }
1159 },
1160 {
1161 { GL_COMPRESSED_RGBA8_ETC2_EAC, 0 },
1162 { PIPE_FORMAT_ETC2_RGBA8, 0 }
1163 },
1164 {
1165 { GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0 },
1166 { PIPE_FORMAT_ETC2_SRGBA8, 0 }
1167 },
1168 {
1169 { GL_COMPRESSED_R11_EAC, 0 },
1170 { PIPE_FORMAT_ETC2_R11_UNORM, 0 }
1171 },
1172 {
1173 { GL_COMPRESSED_SIGNED_R11_EAC, 0 },
1174 { PIPE_FORMAT_ETC2_R11_SNORM, 0 }
1175 },
1176 {
1177 { GL_COMPRESSED_RG11_EAC, 0 },
1178 { PIPE_FORMAT_ETC2_RG11_UNORM, 0 }
1179 },
1180 {
1181 { GL_COMPRESSED_SIGNED_RG11_EAC, 0 },
1182 { PIPE_FORMAT_ETC2_RG11_SNORM, 0 }
1183 },
1184
1185 /* BPTC */
1186 {
1187 { GL_COMPRESSED_RGBA_BPTC_UNORM, 0 },
1188 { PIPE_FORMAT_BPTC_RGBA_UNORM, 0 },
1189 },
1190 {
1191 { GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, 0 },
1192 { PIPE_FORMAT_BPTC_SRGBA, 0 },
1193 },
1194 {
1195 { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, 0 },
1196 { PIPE_FORMAT_BPTC_RGB_FLOAT, 0 },
1197 },
1198 {
1199 { GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, 0 },
1200 { PIPE_FORMAT_BPTC_RGB_UFLOAT, 0 },
1201 },
1202
1203 /* ASTC */
1204 {
1205 { GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0 },
1206 { PIPE_FORMAT_ASTC_4x4, 0},
1207 },
1208 {
1209 { GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0 },
1210 { PIPE_FORMAT_ASTC_5x4, 0},
1211 },
1212 {
1213 { GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0 },
1214 { PIPE_FORMAT_ASTC_5x5, 0},
1215 },
1216 {
1217 { GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0 },
1218 { PIPE_FORMAT_ASTC_6x5, 0},
1219 },
1220 {
1221 { GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0 },
1222 { PIPE_FORMAT_ASTC_6x6, 0},
1223 },
1224 {
1225 { GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0 },
1226 { PIPE_FORMAT_ASTC_8x5, 0},
1227 },
1228 {
1229 { GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0 },
1230 { PIPE_FORMAT_ASTC_8x6, 0},
1231 },
1232 {
1233 { GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0 },
1234 { PIPE_FORMAT_ASTC_8x8, 0},
1235 },
1236 {
1237 { GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0 },
1238 { PIPE_FORMAT_ASTC_10x5, 0},
1239 },
1240 {
1241 { GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0 },
1242 { PIPE_FORMAT_ASTC_10x6, 0},
1243 },
1244 {
1245 { GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0 },
1246 { PIPE_FORMAT_ASTC_10x8, 0},
1247 },
1248 {
1249 { GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0 },
1250 { PIPE_FORMAT_ASTC_10x10, 0},
1251 },
1252 {
1253 { GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0 },
1254 { PIPE_FORMAT_ASTC_12x10, 0},
1255 },
1256 {
1257 { GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0 },
1258 { PIPE_FORMAT_ASTC_12x12, 0},
1259 },
1260
1261 {
1262 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0 },
1263 { PIPE_FORMAT_ASTC_4x4_SRGB, 0},
1264 },
1265 {
1266 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0 },
1267 { PIPE_FORMAT_ASTC_5x4_SRGB, 0},
1268 },
1269 {
1270 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0 },
1271 { PIPE_FORMAT_ASTC_5x5_SRGB, 0},
1272 },
1273 {
1274 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0 },
1275 { PIPE_FORMAT_ASTC_6x5_SRGB, 0},
1276 },
1277 {
1278 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0 },
1279 { PIPE_FORMAT_ASTC_6x6_SRGB, 0},
1280 },
1281 {
1282 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0 },
1283 { PIPE_FORMAT_ASTC_8x5_SRGB, 0},
1284 },
1285 {
1286 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0 },
1287 { PIPE_FORMAT_ASTC_8x6_SRGB, 0},
1288 },
1289 {
1290 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0 },
1291 { PIPE_FORMAT_ASTC_8x8_SRGB, 0},
1292 },
1293 {
1294 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0 },
1295 { PIPE_FORMAT_ASTC_10x5_SRGB, 0},
1296 },
1297 {
1298 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0 },
1299 { PIPE_FORMAT_ASTC_10x6_SRGB, 0},
1300 },
1301 {
1302 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0 },
1303 { PIPE_FORMAT_ASTC_10x8_SRGB, 0},
1304 },
1305 {
1306 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0 },
1307 { PIPE_FORMAT_ASTC_10x10_SRGB, 0},
1308 },
1309 {
1310 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0 },
1311 { PIPE_FORMAT_ASTC_12x10_SRGB, 0},
1312 },
1313 {
1314 { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0 },
1315 { PIPE_FORMAT_ASTC_12x12_SRGB, 0},
1316 },
1317
1318 /* signed/unsigned integer formats.
1319 */
1320 {
1321 { GL_RGBA_INTEGER_EXT,
1322 GL_BGRA_INTEGER_EXT,
1323 GL_RGBA8I_EXT, 0 },
1324 { PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1325 },
1326 {
1327 { GL_RGB_INTEGER_EXT,
1328 GL_BGR_INTEGER_EXT,
1329 GL_RGB8I_EXT,
1330 GL_BLUE_INTEGER_EXT, 0 },
1331 { PIPE_FORMAT_R8G8B8_SINT, PIPE_FORMAT_R8G8B8X8_SINT,
1332 PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1333 },
1334 {
1335 { GL_ALPHA_INTEGER_EXT,
1336 GL_ALPHA8I_EXT, 0 },
1337 { PIPE_FORMAT_A8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1338 },
1339 {
1340 { GL_ALPHA16I_EXT, 0 },
1341 { PIPE_FORMAT_A16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
1342 },
1343 {
1344 { GL_ALPHA32I_EXT, 0 },
1345 { PIPE_FORMAT_A32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1346 },
1347 {
1348 { GL_ALPHA8UI_EXT, 0 },
1349 { PIPE_FORMAT_A8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1350 },
1351 {
1352 { GL_ALPHA16UI_EXT, 0 },
1353 { PIPE_FORMAT_A16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1354 },
1355 {
1356 { GL_ALPHA32UI_EXT, 0 },
1357 { PIPE_FORMAT_A32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1358 },
1359 {
1360 { GL_INTENSITY8I_EXT, 0 },
1361 { PIPE_FORMAT_I8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1362 },
1363 {
1364 { GL_INTENSITY16I_EXT, 0 },
1365 { PIPE_FORMAT_I16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
1366 },
1367 {
1368 { GL_INTENSITY32I_EXT, 0 },
1369 { PIPE_FORMAT_I32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1370 },
1371 {
1372 { GL_INTENSITY8UI_EXT, 0 },
1373 { PIPE_FORMAT_I8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1374 },
1375 {
1376 { GL_INTENSITY16UI_EXT, 0 },
1377 { PIPE_FORMAT_I16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1378 },
1379 {
1380 { GL_INTENSITY32UI_EXT, 0 },
1381 { PIPE_FORMAT_I32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1382 },
1383 {
1384 { GL_LUMINANCE8I_EXT, 0 },
1385 { PIPE_FORMAT_L8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1386 },
1387 {
1388 { GL_LUMINANCE16I_EXT, 0 },
1389 { PIPE_FORMAT_L16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
1390 },
1391 {
1392 { GL_LUMINANCE32I_EXT, 0 },
1393 { PIPE_FORMAT_L32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1394 },
1395 {
1396 { GL_LUMINANCE_INTEGER_EXT,
1397 GL_LUMINANCE8UI_EXT, 0 },
1398 { PIPE_FORMAT_L8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1399 },
1400 {
1401 { GL_LUMINANCE16UI_EXT, 0 },
1402 { PIPE_FORMAT_L16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1403 },
1404 {
1405 { GL_LUMINANCE32UI_EXT, 0 },
1406 { PIPE_FORMAT_L32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1407 },
1408 {
1409 { GL_LUMINANCE_ALPHA_INTEGER_EXT,
1410 GL_LUMINANCE_ALPHA8I_EXT, 0 },
1411 { PIPE_FORMAT_L8A8_SINT, PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1412 },
1413 {
1414 { GL_LUMINANCE_ALPHA16I_EXT, 0 },
1415 { PIPE_FORMAT_L16A16_SINT, PIPE_FORMAT_R16G16B16A16_SINT, 0 }
1416 },
1417 {
1418 { GL_LUMINANCE_ALPHA32I_EXT, 0 },
1419 { PIPE_FORMAT_L32A32_SINT, PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1420 },
1421 {
1422 { GL_LUMINANCE_ALPHA8UI_EXT, 0 },
1423 { PIPE_FORMAT_L8A8_UINT, PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1424 },
1425 {
1426 { GL_LUMINANCE_ALPHA16UI_EXT, 0 },
1427 { PIPE_FORMAT_L16A16_UINT, PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1428 },
1429 {
1430 { GL_LUMINANCE_ALPHA32UI_EXT, 0 },
1431 { PIPE_FORMAT_L32A32_UINT, PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1432 },
1433 {
1434 { GL_RGB16I_EXT, 0 },
1435 { PIPE_FORMAT_R16G16B16_SINT, PIPE_FORMAT_R16G16B16X16_SINT,
1436 PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1437 },
1438 {
1439 { GL_RGBA16I_EXT, 0 },
1440 { PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1441 },
1442 {
1443 { GL_RGB32I_EXT, 0 },
1444 { PIPE_FORMAT_R32G32B32_SINT, PIPE_FORMAT_R32G32B32X32_SINT,
1445 PIPE_FORMAT_R32G32B32A32_SINT, 0 },
1446 },
1447 {
1448 { GL_RGBA32I_EXT, 0 },
1449 { PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1450 },
1451 {
1452 { GL_RGBA8UI_EXT, 0 },
1453 { PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1454 },
1455 {
1456 { GL_RGB8UI_EXT, 0 },
1457 { PIPE_FORMAT_R8G8B8_UINT, PIPE_FORMAT_R8G8B8X8_UINT,
1458 PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1459 },
1460 {
1461 { GL_RGB16UI_EXT, 0 },
1462 { PIPE_FORMAT_R16G16B16_UINT, PIPE_FORMAT_R16G16B16X16_UINT,
1463 PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1464 },
1465 {
1466 { GL_RGBA16UI_EXT, 0 },
1467 { PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1468 },
1469 {
1470 { GL_RGB32UI_EXT, 0},
1471 { PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32X32_UINT,
1472 PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1473 },
1474 {
1475 { GL_RGBA32UI_EXT, 0},
1476 { PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1477 },
1478 {
1479 { GL_R8I, GL_RED_INTEGER_EXT, 0},
1480 { PIPE_FORMAT_R8_SINT, 0},
1481 },
1482 {
1483 { GL_R16I, 0},
1484 { PIPE_FORMAT_R16_SINT, 0},
1485 },
1486 {
1487 { GL_R32I, 0},
1488 { PIPE_FORMAT_R32_SINT, 0},
1489 },
1490 {
1491 { GL_R8UI, 0},
1492 { PIPE_FORMAT_R8_UINT, 0},
1493 },
1494 {
1495 { GL_R16UI, 0},
1496 { PIPE_FORMAT_R16_UINT, 0},
1497 },
1498 {
1499 { GL_R32UI, 0},
1500 { PIPE_FORMAT_R32_UINT, 0},
1501 },
1502 {
1503 { GL_RG8I, GL_GREEN_INTEGER_EXT, 0},
1504 { PIPE_FORMAT_R8G8_SINT, 0},
1505 },
1506 {
1507 { GL_RG16I, 0},
1508 { PIPE_FORMAT_R16G16_SINT, 0},
1509 },
1510 {
1511 { GL_RG32I, 0},
1512 { PIPE_FORMAT_R32G32_SINT, 0},
1513 },
1514 {
1515 { GL_RG8UI, 0},
1516 { PIPE_FORMAT_R8G8_UINT, 0},
1517 },
1518 {
1519 { GL_RG16UI, 0},
1520 { PIPE_FORMAT_R16G16_UINT, 0},
1521 },
1522 {
1523 { GL_RG32UI, 0},
1524 { PIPE_FORMAT_R32G32_UINT, 0},
1525 },
1526 /* signed normalized formats */
1527 {
1528 { GL_RED_SNORM, GL_R8_SNORM, 0 },
1529 { PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM,
1530 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1531 },
1532 {
1533 { GL_R16_SNORM, 0 },
1534 { PIPE_FORMAT_R16_SNORM,
1535 PIPE_FORMAT_R16G16_SNORM,
1536 PIPE_FORMAT_R16G16B16A16_SNORM,
1537 PIPE_FORMAT_R8_SNORM,
1538 PIPE_FORMAT_R8G8_SNORM,
1539 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1540 },
1541 {
1542 { GL_RG_SNORM, GL_RG8_SNORM, 0 },
1543 { PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1544 },
1545 {
1546 { GL_RG16_SNORM, 0 },
1547 { PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1548 PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1549 },
1550 {
1551 { GL_RGB_SNORM, GL_RGB8_SNORM, 0 },
1552 { PIPE_FORMAT_R8G8B8X8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1553 },
1554 {
1555 { GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 },
1556 { PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1557 },
1558 {
1559 { GL_RGB16_SNORM, 0 },
1560 { PIPE_FORMAT_R16G16B16X16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1561 PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1562 },
1563 {
1564 { GL_RGBA16_SNORM, 0 },
1565 { PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1566 },
1567 {
1568 { GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 },
1569 { PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1570 },
1571 {
1572 { GL_ALPHA16_SNORM, 0 },
1573 { PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1574 PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1575 },
1576 {
1577 { GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 },
1578 { PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1579 },
1580 {
1581 { GL_LUMINANCE16_SNORM, 0 },
1582 { PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1583 PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1584 },
1585 {
1586 { GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 },
1587 { PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1588 },
1589 {
1590 { GL_LUMINANCE16_ALPHA16_SNORM, 0 },
1591 { PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1592 PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1593 },
1594 {
1595 { GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 },
1596 { PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1597 },
1598 {
1599 { GL_INTENSITY16_SNORM, 0 },
1600 { PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1601 PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1602 },
1603 {
1604 { GL_RGB9_E5, 0 },
1605 { PIPE_FORMAT_R9G9B9E5_FLOAT, 0 }
1606 },
1607 {
1608 { GL_R11F_G11F_B10F, 0 },
1609 { PIPE_FORMAT_R11G11B10_FLOAT, 0 }
1610 },
1611 {
1612 { GL_RGB10_A2UI, 0 },
1613 { PIPE_FORMAT_R10G10B10A2_UINT, PIPE_FORMAT_B10G10R10A2_UINT, 0 }
1614 },
1615 };
1616
1617
1618 /**
1619 * Return first supported format from the given list.
1620 * \param allow_dxt indicates whether it's OK to return a DXT format.
1621 */
1622 static enum pipe_format
1623 find_supported_format(struct pipe_screen *screen,
1624 const enum pipe_format formats[],
1625 enum pipe_texture_target target,
1626 unsigned sample_count,
1627 unsigned storage_sample_count,
1628 unsigned bindings,
1629 boolean allow_dxt)
1630 {
1631 uint i;
1632 for (i = 0; formats[i]; i++) {
1633 if (screen->is_format_supported(screen, formats[i], target,
1634 sample_count, storage_sample_count,
1635 bindings)) {
1636 if (!allow_dxt && util_format_is_s3tc(formats[i])) {
1637 /* we can't return a dxt format, continue searching */
1638 continue;
1639 }
1640
1641 return formats[i];
1642 }
1643 }
1644 return PIPE_FORMAT_NONE;
1645 }
1646
1647
1648 struct exact_format_mapping
1649 {
1650 GLenum format;
1651 GLenum type;
1652 enum pipe_format pformat;
1653 };
1654
1655 static const struct exact_format_mapping rgba8888_tbl[] =
1656 {
1657 { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_ABGR8888_UNORM },
1658 { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_ABGR8888_UNORM },
1659 { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_RGBA8888_UNORM },
1660 { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_RGBA8888_UNORM },
1661 { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_ARGB8888_UNORM },
1662 { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_BGRA8888_UNORM },
1663 { GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8A8_UNORM },
1664 { GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_A8B8G8R8_UNORM },
1665 { GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8A8_UNORM },
1666 { 0, 0, 0 }
1667 };
1668
1669 static const struct exact_format_mapping rgbx8888_tbl[] =
1670 {
1671 { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_XBGR8888_UNORM },
1672 { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_XBGR8888_UNORM },
1673 { GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_RGBX8888_UNORM },
1674 { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_RGBX8888_UNORM },
1675 { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, PIPE_FORMAT_XRGB8888_UNORM },
1676 { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, PIPE_FORMAT_BGRX8888_UNORM },
1677 { GL_RGBA, GL_UNSIGNED_BYTE, PIPE_FORMAT_R8G8B8X8_UNORM },
1678 { GL_ABGR_EXT, GL_UNSIGNED_BYTE, PIPE_FORMAT_X8B8G8R8_UNORM },
1679 { GL_BGRA, GL_UNSIGNED_BYTE, PIPE_FORMAT_B8G8R8X8_UNORM },
1680 { 0, 0, 0 }
1681 };
1682
1683
1684 /**
1685 * For unsized/base internal formats, we may choose a convenient effective
1686 * internal format for {format, type}. If one exists, return that, otherwise
1687 * return PIPE_FORMAT_NONE.
1688 */
1689 static enum pipe_format
1690 find_exact_format(GLint internalFormat, GLenum format, GLenum type)
1691 {
1692 uint i;
1693 const struct exact_format_mapping* tbl;
1694
1695 if (format == GL_NONE || type == GL_NONE)
1696 return PIPE_FORMAT_NONE;
1697
1698 switch (internalFormat) {
1699 case 4:
1700 case GL_RGBA:
1701 tbl = rgba8888_tbl;
1702 break;
1703 case 3:
1704 case GL_RGB:
1705 tbl = rgbx8888_tbl;
1706 break;
1707 default:
1708 return PIPE_FORMAT_NONE;
1709 }
1710
1711 for (i = 0; tbl[i].format; i++)
1712 if (tbl[i].format == format && tbl[i].type == type)
1713 return tbl[i].pformat;
1714
1715 return PIPE_FORMAT_NONE;
1716 }
1717
1718
1719 /**
1720 * Given an OpenGL internalFormat value for a texture or surface, return
1721 * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
1722 * This is called during glTexImage2D, for example.
1723 *
1724 * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
1725 * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
1726 * we want render-to-texture ability.
1727 *
1728 * \param internalFormat the user value passed to glTexImage2D
1729 * \param target one of PIPE_TEXTURE_x
1730 * \param bindings bitmask of PIPE_BIND_x flags.
1731 * \param allow_dxt indicates whether it's OK to return a DXT format. This
1732 * only matters when internalFormat names a generic or
1733 * specific compressed format. And that should only happen
1734 * when we're getting called from gl[Copy]TexImage().
1735 */
1736 enum pipe_format
1737 st_choose_format(struct st_context *st, GLenum internalFormat,
1738 GLenum format, GLenum type,
1739 enum pipe_texture_target target, unsigned sample_count,
1740 unsigned storage_sample_count,
1741 unsigned bindings, boolean allow_dxt)
1742 {
1743 struct pipe_screen *screen = st->pipe->screen;
1744 unsigned i;
1745 int j;
1746 enum pipe_format pf;
1747
1748 /* can't render to compressed formats at this time */
1749 if (_mesa_is_compressed_format(st->ctx, internalFormat)
1750 && (bindings & ~PIPE_BIND_SAMPLER_VIEW)) {
1751 return PIPE_FORMAT_NONE;
1752 }
1753
1754 /* search for exact matches */
1755 pf = find_exact_format(internalFormat, format, type);
1756 if (pf != PIPE_FORMAT_NONE &&
1757 screen->is_format_supported(screen, pf, target, sample_count,
1758 storage_sample_count, bindings)) {
1759 goto success;
1760 }
1761
1762 /* For an unsized GL_RGB but a 2_10_10_10 type, try to pick one of the
1763 * 2_10_10_10 formats. This is important for
1764 * GL_EXT_texture_type_2_10_10_10_EXT support, which says that these
1765 * formats are not color-renderable. Mesa's check for making those
1766 * non-color-renderable is based on our chosen format being 2101010.
1767 */
1768 if (type == GL_UNSIGNED_INT_2_10_10_10_REV) {
1769 if (internalFormat == GL_RGB)
1770 internalFormat = GL_RGB10;
1771 else if (internalFormat == GL_RGBA)
1772 internalFormat = GL_RGB10_A2;
1773 }
1774
1775 if (type == GL_UNSIGNED_SHORT_5_5_5_1) {
1776 if (internalFormat == GL_RGB)
1777 internalFormat = GL_RGB5;
1778 else if (internalFormat == GL_RGBA)
1779 internalFormat = GL_RGB5_A1;
1780 }
1781
1782 /* search table for internalFormat */
1783 for (i = 0; i < ARRAY_SIZE(format_map); i++) {
1784 const struct format_mapping *mapping = &format_map[i];
1785 for (j = 0; mapping->glFormats[j]; j++) {
1786 if (mapping->glFormats[j] == internalFormat) {
1787 /* Found the desired internal format. Find first pipe format
1788 * which is supported by the driver.
1789 */
1790 pf = find_supported_format(screen, mapping->pipeFormats,
1791 target, sample_count,
1792 storage_sample_count, bindings,
1793 allow_dxt);
1794 goto success;
1795 }
1796 }
1797 }
1798
1799 _mesa_problem(NULL, "unhandled format!\n");
1800 return PIPE_FORMAT_NONE;
1801
1802 success:
1803 if (0) {
1804 debug_printf("%s(fmt=%s, type=%s, intFmt=%s) = %s\n",
1805 __FUNCTION__,
1806 _mesa_enum_to_string(format),
1807 _mesa_enum_to_string(type),
1808 _mesa_enum_to_string(internalFormat),
1809 util_format_name(pf));
1810 }
1811 return pf;
1812 }
1813
1814
1815 /**
1816 * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
1817 */
1818 enum pipe_format
1819 st_choose_renderbuffer_format(struct st_context *st,
1820 GLenum internalFormat, unsigned sample_count,
1821 unsigned storage_sample_count)
1822 {
1823 unsigned bindings;
1824 if (_mesa_is_depth_or_stencil_format(internalFormat))
1825 bindings = PIPE_BIND_DEPTH_STENCIL;
1826 else
1827 bindings = PIPE_BIND_RENDER_TARGET;
1828 return st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
1829 PIPE_TEXTURE_2D, sample_count,
1830 storage_sample_count, bindings, FALSE);
1831 }
1832
1833
1834 /**
1835 * Given an OpenGL user-requested format and type, and swapBytes state,
1836 * return the format which exactly matches those parameters, so that
1837 * a memcpy-based transfer can be done.
1838 *
1839 * If no format is supported, return PIPE_FORMAT_NONE.
1840 */
1841 enum pipe_format
1842 st_choose_matching_format(struct st_context *st, unsigned bind,
1843 GLenum format, GLenum type, GLboolean swapBytes)
1844 {
1845 struct pipe_screen *screen = st->pipe->screen;
1846 mesa_format mesa_format;
1847
1848 for (mesa_format = 1; mesa_format < MESA_FORMAT_COUNT; mesa_format++) {
1849 if (!_mesa_get_format_name(mesa_format))
1850 continue;
1851
1852 if (_mesa_is_format_srgb(mesa_format)) {
1853 continue;
1854 }
1855 if (_mesa_get_format_bits(mesa_format, GL_TEXTURE_INTENSITY_SIZE) > 0) {
1856 /* If `format` is GL_RED/GL_RED_INTEGER, then we might match some
1857 * intensity formats, which we don't want.
1858 */
1859 continue;
1860 }
1861
1862 if (_mesa_format_matches_format_and_type(mesa_format, format, type,
1863 swapBytes, NULL)) {
1864 enum pipe_format format =
1865 st_mesa_format_to_pipe_format(st, mesa_format);
1866
1867 if (format &&
1868 screen->is_format_supported(screen, format, PIPE_TEXTURE_2D,
1869 0, 0, bind)) {
1870 return format;
1871 }
1872 /* It's unlikely to find 2 matching Mesa formats. */
1873 break;
1874 }
1875 }
1876 return PIPE_FORMAT_NONE;
1877 }
1878
1879
1880 /**
1881 * Called via ctx->Driver.ChooseTextureFormat().
1882 */
1883 mesa_format
1884 st_ChooseTextureFormat(struct gl_context *ctx, GLenum target,
1885 GLint internalFormat,
1886 GLenum format, GLenum type)
1887 {
1888 struct st_context *st = st_context(ctx);
1889 enum pipe_format pFormat;
1890 mesa_format mFormat;
1891 unsigned bindings;
1892 bool is_renderbuffer = false;
1893 enum pipe_texture_target pTarget;
1894
1895 if (target == GL_RENDERBUFFER) {
1896 pTarget = PIPE_TEXTURE_2D;
1897 is_renderbuffer = true;
1898 } else {
1899 pTarget = gl_target_to_pipe(target);
1900 }
1901
1902 if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) {
1903 /* We don't do compression for these texture targets because of
1904 * difficulty with sub-texture updates on non-block boundaries, etc.
1905 * So change the internal format request to an uncompressed format.
1906 */
1907 internalFormat =
1908 _mesa_generic_compressed_format_to_uncompressed_format(internalFormat);
1909 }
1910
1911 /* GL textures may wind up being render targets, but we don't know
1912 * that in advance. Specify potential render target flags now for formats
1913 * that we know should always be renderable.
1914 */
1915 bindings = PIPE_BIND_SAMPLER_VIEW;
1916 if (_mesa_is_depth_or_stencil_format(internalFormat))
1917 bindings |= PIPE_BIND_DEPTH_STENCIL;
1918 else if (is_renderbuffer || internalFormat == 3 || internalFormat == 4 ||
1919 internalFormat == GL_RGB || internalFormat == GL_RGBA ||
1920 internalFormat == GL_RGBA2 ||
1921 internalFormat == GL_RGB4 || internalFormat == GL_RGBA4 ||
1922 internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
1923 internalFormat == GL_BGRA ||
1924 internalFormat == GL_RGB16F ||
1925 internalFormat == GL_RGBA16F ||
1926 internalFormat == GL_RGB32F ||
1927 internalFormat == GL_RGBA32F)
1928 bindings |= PIPE_BIND_RENDER_TARGET;
1929
1930 /* GLES allows the driver to choose any format which matches
1931 * the format+type combo, because GLES only supports unsized internal
1932 * formats and expects the driver to choose whatever suits it.
1933 */
1934 if (_mesa_is_gles(ctx)) {
1935 GLenum baseFormat = _mesa_base_tex_format(ctx, internalFormat);
1936 GLenum basePackFormat = _mesa_base_pack_format(format);
1937 GLenum iformat = internalFormat;
1938
1939 /* Treat GL_BGRA as GL_RGBA. */
1940 if (iformat == GL_BGRA)
1941 iformat = GL_RGBA;
1942
1943 /* Check if the internalformat is unsized and compatible
1944 * with the "format".
1945 */
1946 if (iformat == baseFormat && iformat == basePackFormat) {
1947 pFormat = st_choose_matching_format(st, bindings, format, type,
1948 ctx->Unpack.SwapBytes);
1949
1950 if (pFormat != PIPE_FORMAT_NONE)
1951 return st_pipe_format_to_mesa_format(pFormat);
1952
1953 if (!is_renderbuffer) {
1954 /* try choosing format again, this time without render
1955 * target bindings.
1956 */
1957 pFormat = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
1958 format, type,
1959 ctx->Unpack.SwapBytes);
1960 if (pFormat != PIPE_FORMAT_NONE)
1961 return st_pipe_format_to_mesa_format(pFormat);
1962 }
1963 }
1964 }
1965
1966 pFormat = st_choose_format(st, internalFormat, format, type,
1967 pTarget, 0, 0, bindings, GL_TRUE);
1968
1969 if (pFormat == PIPE_FORMAT_NONE && !is_renderbuffer) {
1970 /* try choosing format again, this time without render target bindings */
1971 pFormat = st_choose_format(st, internalFormat, format, type,
1972 pTarget, 0, 0, PIPE_BIND_SAMPLER_VIEW,
1973 GL_TRUE);
1974 }
1975
1976 if (pFormat == PIPE_FORMAT_NONE) {
1977 mFormat = _mesa_glenum_to_compressed_format(internalFormat);
1978 if (st_compressed_format_fallback(st, mFormat))
1979 return mFormat;
1980
1981 /* no luck at all */
1982 return MESA_FORMAT_NONE;
1983 }
1984
1985 mFormat = st_pipe_format_to_mesa_format(pFormat);
1986
1987 /* Debugging aid */
1988 if (0) {
1989 debug_printf("%s(intFormat=%s, format=%s, type=%s) -> %s, %s\n",
1990 __func__,
1991 _mesa_enum_to_string(internalFormat),
1992 _mesa_enum_to_string(format),
1993 _mesa_enum_to_string(type),
1994 util_format_name(pFormat),
1995 _mesa_get_format_name(mFormat));
1996 }
1997
1998 return mFormat;
1999 }
2000
2001
2002 /**
2003 * Called via ctx->Driver.QueryInternalFormat().
2004 */
2005 static size_t
2006 st_QuerySamplesForFormat(struct gl_context *ctx, GLenum target,
2007 GLenum internalFormat, int samples[16])
2008 {
2009 struct st_context *st = st_context(ctx);
2010 enum pipe_format format;
2011 unsigned i, bind, num_sample_counts = 0;
2012
2013 (void) target;
2014
2015 if (_mesa_is_depth_or_stencil_format(internalFormat))
2016 bind = PIPE_BIND_DEPTH_STENCIL;
2017 else
2018 bind = PIPE_BIND_RENDER_TARGET;
2019
2020 /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
2021 * formats.
2022 */
2023 if (!ctx->Extensions.EXT_sRGB) {
2024 internalFormat = _mesa_get_linear_internalformat(internalFormat);
2025 }
2026
2027 /* Set sample counts in descending order. */
2028 for (i = 16; i > 1; i--) {
2029 format = st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
2030 PIPE_TEXTURE_2D, i, i, bind, FALSE);
2031
2032 if (format != PIPE_FORMAT_NONE) {
2033 samples[num_sample_counts++] = i;
2034 }
2035 }
2036
2037 if (!num_sample_counts) {
2038 samples[num_sample_counts++] = 1;
2039 }
2040
2041 return num_sample_counts;
2042 }
2043
2044
2045 /**
2046 * ARB_internalformat_query2 driver hook.
2047 */
2048 void
2049 st_QueryInternalFormat(struct gl_context *ctx, GLenum target,
2050 GLenum internalFormat, GLenum pname, GLint *params)
2051 {
2052 struct st_context *st = st_context(ctx);
2053 /* The API entry-point gives us a temporary params buffer that is non-NULL
2054 * and guaranteed to have at least 16 elements.
2055 */
2056 assert(params != NULL);
2057
2058 switch (pname) {
2059 case GL_SAMPLES:
2060 st_QuerySamplesForFormat(ctx, target, internalFormat, params);
2061 break;
2062
2063 case GL_NUM_SAMPLE_COUNTS: {
2064 int samples[16];
2065 size_t num_samples;
2066 num_samples = st_QuerySamplesForFormat(ctx, target, internalFormat,
2067 samples);
2068 params[0] = (GLint) num_samples;
2069 break;
2070 }
2071 case GL_INTERNALFORMAT_PREFERRED: {
2072 params[0] = GL_NONE;
2073
2074 /* We need to resolve an internal format that is compatible with
2075 * the passed internal format, and optimal to the driver. By now,
2076 * we just validate that the passed internal format is supported by
2077 * the driver, and if so return the same internal format, otherwise
2078 * return GL_NONE.
2079 */
2080 unsigned bindings;
2081 if (_mesa_is_depth_or_stencil_format(internalFormat))
2082 bindings = PIPE_BIND_DEPTH_STENCIL;
2083 else
2084 bindings = PIPE_BIND_RENDER_TARGET;
2085 enum pipe_format pformat = st_choose_format(st,
2086 internalFormat,
2087 GL_NONE,
2088 GL_NONE,
2089 PIPE_TEXTURE_2D, 0, 0,
2090 bindings, FALSE);
2091 if (pformat)
2092 params[0] = internalFormat;
2093 break;
2094 }
2095 default:
2096 /* For the rest of the pnames, we call back the Mesa's default
2097 * function for drivers that don't implement ARB_internalformat_query2.
2098 */
2099 _mesa_query_internal_format_default(ctx, target, internalFormat, pname,
2100 params);
2101 }
2102 }
2103
2104
2105 /**
2106 * This is used for translating texture border color and the clear
2107 * color. For example, the clear color is interpreted according to
2108 * the renderbuffer's base format. For example, if clearing a
2109 * GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
2110 * colorOut[2] = colorIn[0].
2111 * Similarly for texture border colors.
2112 */
2113 void
2114 st_translate_color(const union gl_color_union *colorIn,
2115 union pipe_color_union *colorOut,
2116 GLenum baseFormat, GLboolean is_integer)
2117 {
2118 if (is_integer) {
2119 const int *in = colorIn->i;
2120 int *out = colorOut->i;
2121
2122 switch (baseFormat) {
2123 case GL_RED:
2124 out[0] = in[0];
2125 out[1] = 0;
2126 out[2] = 0;
2127 out[3] = 1;
2128 break;
2129 case GL_RG:
2130 out[0] = in[0];
2131 out[1] = in[1];
2132 out[2] = 0;
2133 out[3] = 1;
2134 break;
2135 case GL_RGB:
2136 out[0] = in[0];
2137 out[1] = in[1];
2138 out[2] = in[2];
2139 out[3] = 1;
2140 break;
2141 case GL_ALPHA:
2142 out[0] = out[1] = out[2] = 0;
2143 out[3] = in[3];
2144 break;
2145 case GL_LUMINANCE:
2146 out[0] = out[1] = out[2] = in[0];
2147 out[3] = 1;
2148 break;
2149 case GL_LUMINANCE_ALPHA:
2150 out[0] = out[1] = out[2] = in[0];
2151 out[3] = in[3];
2152 break;
2153 case GL_INTENSITY:
2154 out[0] = out[1] = out[2] = out[3] = in[0];
2155 break;
2156 default:
2157 COPY_4V(out, in);
2158 }
2159 }
2160 else {
2161 const float *in = colorIn->f;
2162 float *out = colorOut->f;
2163
2164 switch (baseFormat) {
2165 case GL_RED:
2166 out[0] = in[0];
2167 out[1] = 0.0F;
2168 out[2] = 0.0F;
2169 out[3] = 1.0F;
2170 break;
2171 case GL_RG:
2172 out[0] = in[0];
2173 out[1] = in[1];
2174 out[2] = 0.0F;
2175 out[3] = 1.0F;
2176 break;
2177 case GL_RGB:
2178 out[0] = in[0];
2179 out[1] = in[1];
2180 out[2] = in[2];
2181 out[3] = 1.0F;
2182 break;
2183 case GL_ALPHA:
2184 out[0] = out[1] = out[2] = 0.0F;
2185 out[3] = in[3];
2186 break;
2187 case GL_LUMINANCE:
2188 out[0] = out[1] = out[2] = in[0];
2189 out[3] = 1.0F;
2190 break;
2191 case GL_LUMINANCE_ALPHA:
2192 out[0] = out[1] = out[2] = in[0];
2193 out[3] = in[3];
2194 break;
2195 /* Stencil border is tricky on some hw. Help drivers a little here. */
2196 case GL_STENCIL_INDEX:
2197 case GL_INTENSITY:
2198 out[0] = out[1] = out[2] = out[3] = in[0];
2199 break;
2200 default:
2201 COPY_4V(out, in);
2202 }
2203 }
2204 }