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