projects / mesa.git / blob
? search:


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