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