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