projects / mesa.git / blob
? search:


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